// /usr/lib/gcc/i686-linux-gnu/4.8/cc1plus -quiet -I . -I . -imultiarch i386-linux-gnu -D_GNU_SOURCE -D_REENTRANT -D HAVE_CONFIG_H -D _FORTIFY_SOURCE=2 drizzled/item/cmpfunc.cc -quiet -dumpbase cmpfunc.cc -mtune=generic -march=i686 -auxbase-strip drizzled/item/cmpfunc.o -g -g -O2 -O2 -Wpedantic -Wall -Wundef -Wshadow -Wno-strict-aliasing -Wextra -Wformat=1 -Wno-format-nonliteral -Wno-format-security -Woverloaded-virtual -Wnon-virtual-dtor -Wctor-dtor-privacy -Wno-long-long -Wmissing-declarations -Wframe-larger-than=32768 -Wredundant-decls -Wformat=1 -Werror=format-security -std=gnu++98 -fvisibility=hidden -fvisibility-inlines-hidden -fdiagnostics-show-option -floop-parallelize-all -fno-strict-aliasing -fstack-protector --param ssp-buffer-size=4 -fstack-protector -o - -frandom-seed=0
# 1 "drizzled/item/cmpfunc.cc"
# 1 "/build/drizzle-qt9se2/drizzle-7.1.36-stable//"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 30 "/usr/include/stdc-predef.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/predefs.h" 1 3 4
# 31 "/usr/include/stdc-predef.h" 2 3 4
# 1 "<command-line>" 2
# 1 "drizzled/item/cmpfunc.cc"
# 24 "drizzled/item/cmpfunc.cc"
# 1 "./config.h" 1
# 13 "./config.h"
# 1 "./config/top.h" 1
# 14 "./config.h" 2
# 849 "./config.h"
# 1 "/usr/include/c++/4.8/tr1/cstdint" 1 3
# 32 "/usr/include/c++/4.8/tr1/cstdint" 3
       
# 33 "/usr/include/c++/4.8/tr1/cstdint" 3

# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++config.h" 1 3
# 184 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++config.h" 3
namespace std
{
  typedef unsigned int size_t;
  typedef int ptrdiff_t;




}
# 426 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++config.h" 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/os_defines.h" 1 3
# 39 "/usr/include/i386-linux-gnu/c++/4.8/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 371 "/usr/include/features.h" 3 4
# 1 "/usr/include/i386-linux-gnu/sys/cdefs.h" 1 3 4
# 385 "/usr/include/i386-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 386 "/usr/include/i386-linux-gnu/sys/cdefs.h" 2 3 4
# 372 "/usr/include/features.h" 2 3 4
# 395 "/usr/include/features.h" 3 4
# 1 "/usr/include/i386-linux-gnu/gnu/stubs.h" 1 3 4






# 1 "/usr/include/i386-linux-gnu/gnu/stubs-32.h" 1 3 4
# 8 "/usr/include/i386-linux-gnu/gnu/stubs.h" 2 3 4
# 396 "/usr/include/features.h" 2 3 4
# 40 "/usr/include/i386-linux-gnu/c++/4.8/bits/os_defines.h" 2 3
# 427 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++config.h" 2 3


# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/cpu_defines.h" 1 3
# 430 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++config.h" 2 3
# 35 "/usr/include/c++/4.8/tr1/cstdint" 2 3
# 46 "/usr/include/c++/4.8/tr1/cstdint" 3
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wchar.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/stdint.h" 2 3 4
# 36 "/usr/include/stdint.h" 3 4
typedef signed char int8_t;
typedef short int int16_t;
typedef int int32_t;



__extension__
typedef long long int int64_t;




typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;

typedef unsigned int uint32_t;





__extension__
typedef unsigned long long int uint64_t;






typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;



__extension__
typedef long long int int_least64_t;



typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;



__extension__
typedef unsigned long long int uint_least64_t;






typedef signed char int_fast8_t;





typedef int int_fast16_t;
typedef int int_fast32_t;
__extension__
typedef long long int int_fast64_t;



typedef unsigned char uint_fast8_t;





typedef unsigned int uint_fast16_t;
typedef unsigned int uint_fast32_t;
__extension__
typedef unsigned long long int uint_fast64_t;
# 125 "/usr/include/stdint.h" 3 4
typedef int intptr_t;


typedef unsigned int uintptr_t;
# 137 "/usr/include/stdint.h" 3 4
__extension__
typedef long long int intmax_t;
__extension__
typedef unsigned long long int uintmax_t;
# 10 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdint.h" 2 3 4
# 47 "/usr/include/c++/4.8/tr1/cstdint" 2 3
# 59 "/usr/include/c++/4.8/tr1/cstdint" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace tr1
{
  using ::int8_t;
  using ::int16_t;
  using ::int32_t;
  using ::int64_t;

  using ::int_fast8_t;
  using ::int_fast16_t;
  using ::int_fast32_t;
  using ::int_fast64_t;

  using ::int_least8_t;
  using ::int_least16_t;
  using ::int_least32_t;
  using ::int_least64_t;

  using ::intmax_t;
  using ::intptr_t;

  using ::uint8_t;
  using ::uint16_t;
  using ::uint32_t;
  using ::uint64_t;

  using ::uint_fast8_t;
  using ::uint_fast16_t;
  using ::uint_fast32_t;
  using ::uint_fast64_t;

  using ::uint_least8_t;
  using ::uint_least16_t;
  using ::uint_least32_t;
  using ::uint_least64_t;

  using ::uintmax_t;
  using ::uintptr_t;
}
}
# 850 "./config.h" 2
# 1 "/usr/include/c++/4.8/tr1/cinttypes" 1 3
# 32 "/usr/include/c++/4.8/tr1/cinttypes" 3
       
# 33 "/usr/include/c++/4.8/tr1/cinttypes" 3
# 42 "/usr/include/c++/4.8/tr1/cinttypes" 3
# 1 "/usr/include/inttypes.h" 1 3 4
# 273 "/usr/include/inttypes.h" 3 4
extern "C" {
# 287 "/usr/include/inttypes.h" 3 4
typedef struct
  {
    long long int quot;
    long long int rem;
  } imaxdiv_t;





extern intmax_t imaxabs (intmax_t __n) throw () __attribute__ ((__const__));


extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom)
      throw () __attribute__ ((__const__));


extern intmax_t strtoimax (const char *__restrict __nptr,
      char **__restrict __endptr, int __base) throw ();


extern uintmax_t strtoumax (const char *__restrict __nptr,
       char ** __restrict __endptr, int __base) throw ();


extern intmax_t wcstoimax (const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr, int __base)
     throw ();


extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr,
       wchar_t ** __restrict __endptr, int __base)
     throw ();
# 377 "/usr/include/inttypes.h" 3 4
__extension__
extern long long int __strtoll_internal (const char *__restrict __nptr,
      char **__restrict __endptr,
      int __base, int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) strtoimax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()

{
  return __strtoll_internal (nptr, endptr, base, 0);
}

__extension__
extern unsigned long long int __strtoull_internal (const char *
         __restrict __nptr,
         char **
         __restrict __endptr,
         int __base,
         int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) strtoumax (const char *__restrict nptr, char **__restrict endptr, int base) throw ()

{
  return __strtoull_internal (nptr, endptr, base, 0);
}

__extension__
extern long long int __wcstoll_internal (const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr,
      int __base, int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) intmax_t
__attribute__ ((__leaf__)) wcstoimax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()

{
  return __wcstoll_internal (nptr, endptr, base, 0);
}


__extension__
extern unsigned long long int __wcstoull_internal (const wchar_t *
         __restrict __nptr,
         wchar_t **
         __restrict __endptr,
         int __base,
         int __group)
  throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));

extern __inline __attribute__ ((__gnu_inline__)) uintmax_t
__attribute__ ((__leaf__)) wcstoumax (const wchar_t *__restrict nptr, wchar_t **__restrict endptr, int base) throw ()

{
  return __wcstoull_internal (nptr, endptr, base, 0);
}




}
# 43 "/usr/include/c++/4.8/tr1/cinttypes" 2 3
# 51 "/usr/include/c++/4.8/tr1/cinttypes" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
namespace tr1
{

  using ::imaxdiv_t;


  using ::imaxabs;






  using ::imaxdiv;





  using ::strtoimax;
  using ::strtoumax;


  using ::wcstoimax;
  using ::wcstoumax;

}
}
# 851 "./config.h" 2
# 884 "./config.h"
template<typename To, typename From>
inline To implicit_cast(From const &f) {
  return f;
}
template<typename To, typename From>
inline To down_cast(From* f) {




  if (false) {
    implicit_cast<From*, To>(0);
  }




  return static_cast<To>(f);
}
# 25 "drizzled/item/cmpfunc.cc" 2

# 1 "./drizzled/cached_item.h" 1
# 20 "./drizzled/cached_item.h"
       

# 1 "./drizzled/memory/sql_alloc.h" 1
# 20 "./drizzled/memory/sql_alloc.h"
       

# 1 "./drizzled/memory/root.h" 1
# 21 "./drizzled/memory/root.h"
       

# 1 "./drizzled/common_fwd.h" 1
# 18 "./drizzled/common_fwd.h"
       

# 1 "/usr/include/boost/shared_ptr.hpp" 1 3 4
# 17 "/usr/include/boost/shared_ptr.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 1 3 4
# 17 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
# 1 "/usr/include/boost/config.hpp" 1 3 4
# 26 "/usr/include/boost/config.hpp" 3 4
# 1 "/usr/include/boost/config/user.hpp" 1 3 4
# 27 "/usr/include/boost/config.hpp" 2 3 4




# 1 "/usr/include/boost/config/select_compiler_config.hpp" 1 3 4
# 32 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/compiler/gcc.hpp" 1 3 4
# 36 "/usr/include/boost/config.hpp" 2 3 4




# 1 "/usr/include/boost/config/select_stdlib_config.hpp" 1 3 4
# 18 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 147 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 3 4
typedef int ptrdiff_t;
# 212 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 3 4
typedef unsigned int size_t;
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 19 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
# 37 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
# 1 "/usr/include/boost/config/no_tr1/utility.hpp" 1 3 4
# 21 "/usr/include/boost/config/no_tr1/utility.hpp" 3 4
# 1 "/usr/include/c++/4.8/utility" 1 3 4
# 58 "/usr/include/c++/4.8/utility" 3 4
       
# 59 "/usr/include/c++/4.8/utility" 3
# 69 "/usr/include/c++/4.8/utility" 3
# 1 "/usr/include/c++/4.8/bits/stl_relops.h" 1 3
# 67 "/usr/include/c++/4.8/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
  namespace rel_ops
  {
 
# 85 "/usr/include/c++/4.8/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 98 "/usr/include/c++/4.8/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 111 "/usr/include/c++/4.8/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 124 "/usr/include/c++/4.8/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }

 
  }

}
# 70 "/usr/include/c++/4.8/utility" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_pair.h" 1 3
# 59 "/usr/include/c++/4.8/bits/stl_pair.h" 3
# 1 "/usr/include/c++/4.8/bits/move.h" 1 3
# 34 "/usr/include/c++/4.8/bits/move.h" 3
# 1 "/usr/include/c++/4.8/bits/concept_check.h" 1 3
# 33 "/usr/include/c++/4.8/bits/concept_check.h" 3
       
# 34 "/usr/include/c++/4.8/bits/concept_check.h" 3
# 35 "/usr/include/c++/4.8/bits/move.h" 2 3

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)));
    }


}
# 149 "/usr/include/c++/4.8/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 164 "/usr/include/c++/4.8/bits/move.h" 3
  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]);
    }



}
# 60 "/usr/include/c++/4.8/bits/stl_pair.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{

# 95 "/usr/include/c++/4.8/bits/stl_pair.h" 3
  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) { }
# 209 "/usr/include/c++/4.8/bits/stl_pair.h" 3
    };


  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); }
# 284 "/usr/include/c++/4.8/bits/stl_pair.h" 3
  template<class _T1, class _T2>
    inline pair<_T1, _T2>
    make_pair(_T1 __x, _T2 __y)
    { return pair<_T1, _T2>(__x, __y); }





}
# 71 "/usr/include/c++/4.8/utility" 2 3
# 22 "/usr/include/boost/config/no_tr1/utility.hpp" 2 3 4
# 38 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
# 41 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
# 76 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
# 1 "/usr/include/unistd.h" 1 3 4
# 27 "/usr/include/unistd.h" 3 4
extern "C" {
# 202 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/posix_opt.h" 1 3 4
# 203 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/i386-linux-gnu/bits/environments.h" 1 3 4
# 22 "/usr/include/i386-linux-gnu/bits/environments.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/environments.h" 2 3 4
# 207 "/usr/include/unistd.h" 2 3 4
# 217 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/i386-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/i386-linux-gnu/bits/types.h" 2 3 4


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;




__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 130 "/usr/include/i386-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/typesizes.h" 1 3 4
# 131 "/usr/include/i386-linux-gnu/bits/types.h" 2 3 4


__extension__ typedef __u_quad_t __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef __u_quad_t __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef __u_quad_t __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef void * __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef __quad_t __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef __u_quad_t __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef __u_quad_t __fsfilcnt64_t;


__extension__ typedef int __fsword_t;

__extension__ typedef int __ssize_t;


__extension__ typedef long int __syscall_slong_t;

__extension__ typedef unsigned long int __syscall_ulong_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 218 "/usr/include/unistd.h" 2 3 4


typedef __ssize_t ssize_t;





# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 227 "/usr/include/unistd.h" 2 3 4





typedef __gid_t gid_t;




typedef __uid_t uid_t;







typedef __off64_t off_t;




typedef __off64_t off64_t;




typedef __useconds_t useconds_t;




typedef __pid_t pid_t;
# 274 "/usr/include/unistd.h" 3 4
typedef __socklen_t socklen_t;
# 287 "/usr/include/unistd.h" 3 4
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__));
# 337 "/usr/include/unistd.h" 3 4
extern __off64_t lseek (int __fd, __off64_t __offset, int __whence) throw () __asm__ ("" "lseek64")

             ;





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__));
# 388 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")

               __attribute__ ((__warn_unused_result__));
extern ssize_t pwrite (int __fd, const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64")

                __attribute__ ((__warn_unused_result__));
# 404 "/usr/include/unistd.h" 3 4
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__));
# 432 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 444 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);







extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     throw ();






extern int usleep (__useconds_t __useconds);
# 469 "/usr/include/unistd.h" 3 4
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__));
# 511 "/usr/include/unistd.h" 3 4
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__));





# 1 "/usr/include/i386-linux-gnu/bits/confname.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/bits/confname.h" 3 4
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

  };
# 610 "/usr/include/unistd.h" 2 3 4


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 ();
# 646 "/usr/include/unistd.h" 3 4
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 ();
# 672 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
# 689 "/usr/include/unistd.h" 3 4
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 () __attribute__ ((__warn_unused_result__));




extern int setreuid (__uid_t __ruid, __uid_t __euid) throw () __attribute__ ((__warn_unused_result__));




extern int seteuid (__uid_t __uid) throw () __attribute__ ((__warn_unused_result__));






extern int setgid (__gid_t __gid) throw () __attribute__ ((__warn_unused_result__));




extern int setregid (__gid_t __rgid, __gid_t __egid) throw () __attribute__ ((__warn_unused_result__));




extern int setegid (__gid_t __gid) throw () __attribute__ ((__warn_unused_result__));





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 () __attribute__ ((__warn_unused_result__));



extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
     throw () __attribute__ ((__warn_unused_result__));






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)));
# 893 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 49 "/usr/include/getopt.h" 3 4
extern "C" {
# 58 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 72 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 151 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       throw ();
# 186 "/usr/include/getopt.h" 3 4
}
# 894 "/usr/include/unistd.h" 2 3 4







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 ();
# 1019 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off64_t __length) throw () __asm__ ("" "truncate64")

                  __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int truncate64 (const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 1041 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off64_t __length) throw () __asm__ ("" "ftruncate64")
                   __attribute__ ((__warn_unused_result__));





extern int ftruncate64 (int __fd, __off64_t __length) throw () __attribute__ ((__warn_unused_result__));
# 1059 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () __attribute__ ((__warn_unused_result__));





extern void *sbrk (intptr_t __delta) throw ();
# 1080 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1106 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off64_t __len) __asm__ ("" "lockf64")
                  __attribute__ ((__warn_unused_result__));





extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
# 1134 "/usr/include/unistd.h" 3 4
extern int fdatasync (int __fildes);







extern char *crypt (const char *__key, const char *__salt)
     throw () __attribute__ ((__nonnull__ (1, 2)));



extern void encrypt (char *__libc_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)));
# 1169 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/unistd.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/unistd.h" 3 4
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__)) __attribute__ ((__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")))
                                  ;
# 86 "/usr/include/i386-linux-gnu/bits/unistd.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
pread (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 __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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);
}
# 1170 "/usr/include/unistd.h" 2 3 4


}
# 77 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 2 3 4
# 45 "/usr/include/boost/config.hpp" 2 3 4




# 1 "/usr/include/boost/config/select_platform_config.hpp" 1 3 4
# 50 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
# 15 "/usr/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 72 "/usr/include/c++/4.8/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 32 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 33 "/usr/include/stdlib.h" 2 3 4

extern "C" {






# 1 "/usr/include/i386-linux-gnu/bits/waitflags.h" 1 3 4
# 42 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/bits/waitstatus.h" 1 3 4
# 64 "/usr/include/i386-linux-gnu/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 36 "/usr/include/endian.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 2 3 4
# 60 "/usr/include/endian.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/byteswap.h" 1 3 4
# 28 "/usr/include/i386-linux-gnu/bits/byteswap.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 29 "/usr/include/i386-linux-gnu/bits/byteswap.h" 2 3 4






# 1 "/usr/include/i386-linux-gnu/bits/byteswap-16.h" 1 3 4
# 36 "/usr/include/i386-linux-gnu/bits/byteswap.h" 2 3 4
# 44 "/usr/include/i386-linux-gnu/bits/byteswap.h" 3 4
static __inline unsigned int
__bswap_32 (unsigned int __bsx)
{
  return __builtin_bswap32 (__bsx);
}
# 108 "/usr/include/i386-linux-gnu/bits/byteswap.h" 3 4
static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{
  return __builtin_bswap64 (__bsx);
}
# 61 "/usr/include/endian.h" 2 3 4
# 65 "/usr/include/i386-linux-gnu/bits/waitstatus.h" 2 3 4

union wait
  {
    int w_status;
    struct
      {

 unsigned int __w_termsig:7;
 unsigned int __w_coredump:1;
 unsigned int __w_retcode:8;
 unsigned int:16;







      } __wait_terminated;
    struct
      {

 unsigned int __w_stopval:8;
 unsigned int __w_stopsig:8;
 unsigned int:16;






      } __wait_stopped;
  };
# 43 "/usr/include/stdlib.h" 2 3 4
# 95 "/usr/include/stdlib.h" 3 4


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;


# 139 "/usr/include/stdlib.h" 3 4
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)));





extern float strtof (const char *__restrict __nptr,
       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));

extern long double strtold (const char *__restrict __nptr,
       char **__restrict __endptr)
     throw () __attribute__ ((__nonnull__ (1)));





extern long int strtol (const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoq (const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));





__extension__
extern long long int strtoll (const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     throw () __attribute__ ((__nonnull__ (1)));

# 235 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 27 "/usr/include/xlocale.h" 3 4
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;
# 236 "/usr/include/stdlib.h" 2 3 4



extern long int strtol_l (const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 4)));

__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)));

extern double strtod_l (const char *__restrict __nptr,
   char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
         char **__restrict __endptr, __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         __locale_t __loc)
     throw () __attribute__ ((__nonnull__ (1, 3)));





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);
}

# 305 "/usr/include/stdlib.h" 3 4
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__));




# 1 "/usr/include/i386-linux-gnu/sys/types.h" 1 3 4
# 27 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
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 __ino64_t ino_t;




typedef __ino64_t ino64_t;




typedef __dev_t dev_t;
# 70 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
typedef __mode_t mode_t;




typedef __nlink_t nlink_t;
# 104 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
typedef __id_t id_t;
# 115 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 132 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 57 "/usr/include/time.h" 3 4


typedef __clock_t clock_t;



# 73 "/usr/include/time.h" 3 4


typedef __time_t time_t;



# 91 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 103 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 133 "/usr/include/i386-linux-gnu/sys/types.h" 2 3 4







typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 147 "/usr/include/i386-linux-gnu/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 200 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
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__)));
# 219 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/i386-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/i386-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/select.h" 1 3 4
# 22 "/usr/include/i386-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/i386-linux-gnu/sys/select.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/sigset.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/sigset.h" 3 4
typedef int __sig_atomic_t;




typedef struct
  {
    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
  } __sigset_t;
# 34 "/usr/include/i386-linux-gnu/sys/select.h" 2 3 4



typedef __sigset_t sigset_t;





# 1 "/usr/include/time.h" 1 3 4
# 120 "/usr/include/time.h" 3 4
struct timespec
  {
    __time_t tv_sec;
    __syscall_slong_t tv_nsec;
  };
# 44 "/usr/include/i386-linux-gnu/sys/select.h" 2 3 4

# 1 "/usr/include/i386-linux-gnu/bits/time.h" 1 3 4
# 30 "/usr/include/i386-linux-gnu/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 46 "/usr/include/i386-linux-gnu/sys/select.h" 2 3 4
# 54 "/usr/include/i386-linux-gnu/sys/select.h" 3 4
typedef long int __fd_mask;
# 64 "/usr/include/i386-linux-gnu/sys/select.h" 3 4
typedef struct
  {



    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];





  } fd_set;






typedef __fd_mask fd_mask;
# 96 "/usr/include/i386-linux-gnu/sys/select.h" 3 4
extern "C" {
# 106 "/usr/include/i386-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 118 "/usr/include/i386-linux-gnu/sys/select.h" 3 4
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);





# 1 "/usr/include/i386-linux-gnu/bits/select2.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/select2.h" 3 4
extern long int __fdelt_chk (long int __d);
extern long int __fdelt_warn (long int __d)
  __attribute__((__warning__ ("bit outside of fd_set selected")));
# 129 "/usr/include/i386-linux-gnu/sys/select.h" 2 3 4


}
# 220 "/usr/include/i386-linux-gnu/sys/types.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/i386-linux-gnu/sys/sysmacros.h" 3 4
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));
}

}
# 223 "/usr/include/i386-linux-gnu/sys/types.h" 2 3 4





typedef __blksize_t blksize_t;
# 248 "/usr/include/i386-linux-gnu/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt_t;



typedef __fsblkcnt64_t fsblkcnt_t;



typedef __fsfilcnt64_t fsfilcnt_t;





typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





# 1 "/usr/include/i386-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 21 "/usr/include/i386-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/i386-linux-gnu/bits/pthreadtypes.h" 2 3 4
# 60 "/usr/include/i386-linux-gnu/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;


union pthread_attr_t
{
  char __size[36];
  long int __align;
};

typedef union pthread_attr_t pthread_attr_t;
# 81 "/usr/include/i386-linux-gnu/bits/pthreadtypes.h" 3 4
typedef struct __pthread_internal_slist
{
  struct __pthread_internal_slist *__next;
} __pthread_slist_t;





typedef union
{
  struct __pthread_mutex_s
  {
    int __lock;
    unsigned int __count;
    int __owner;





    int __kind;





    unsigned int __nusers;
    __extension__ union
    {
      int __spins;
      __pthread_slist_t __list;
    };

  } __data;
  char __size[24];
  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
{
# 185 "/usr/include/i386-linux-gnu/bits/pthreadtypes.h" 3 4
  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;


    unsigned char __flags;
    unsigned char __shared;
    unsigned char __pad1;
    unsigned char __pad2;
    int __writer;
  } __data;

  char __size[32];
  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[20];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 271 "/usr/include/i386-linux-gnu/sys/types.h" 2 3 4


}
# 315 "/usr/include/stdlib.h" 2 3 4






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 ();



# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) throw ();





}
# 492 "/usr/include/stdlib.h" 2 3 4





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 *aligned_alloc (size_t __alignment, size_t __size)
     throw () __attribute__ ((__warn_unused_result__)) __attribute__ ((__malloc__, __alloc_size__ (2)));




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 ();
# 605 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 622 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 644 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __asm__ ("" "mkstemps64")
                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 662 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 676 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __asm__ ("" "mkostemp64")
     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));





extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
# 697 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags) __asm__ ("" "mkostemps64")

     __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__));
# 733 "/usr/include/stdlib.h" 3 4
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__));

# 807 "/usr/include/stdlib.h" 3 4
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__));
# 895 "/usr/include/stdlib.h" 3 4
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)));


# 1 "/usr/include/i386-linux-gnu/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/stdlib-float.h" 3 4

extern __inline __attribute__ ((__gnu_inline__)) double
__attribute__ ((__leaf__)) atof (const char *__nptr) throw ()
{
  return strtod (__nptr, (char **) __null);
}

# 952 "/usr/include/stdlib.h" 2 3 4



# 1 "/usr/include/i386-linux-gnu/bits/stdlib.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/stdlib.h" 3 4
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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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);
}
# 956 "/usr/include/stdlib.h" 2 3 4
# 964 "/usr/include/stdlib.h" 3 4
}
# 73 "/usr/include/c++/4.8/cstdlib" 2 3
# 114 "/usr/include/c++/4.8/cstdlib" 3
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 __builtin_labs(__i); }

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }



  inline long long
  abs(long long __x) { return __builtin_llabs (__x); }








}
# 196 "/usr/include/c++/4.8/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  using ::lldiv_t;





  using ::_Exit;



  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;
# 228 "/usr/include/c++/4.8/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;


}

namespace std
{

  using ::__gnu_cxx::lldiv_t;

  using ::__gnu_cxx::_Exit;

  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;
}
# 16 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
# 74 "/usr/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/include/boost/config/posix_features.hpp" 1 3 4
# 75 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
# 54 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/suffix.hpp" 1 3 4
# 34 "/usr/include/boost/config/suffix.hpp" 3 4
       
# 35 "/usr/include/boost/config/suffix.hpp" 3
# 482 "/usr/include/boost/config/suffix.hpp" 3
namespace boost{

   __extension__ typedef long long long_long_type;
   __extension__ typedef unsigned long long ulong_long_type;




}
# 58 "/usr/include/boost/config.hpp" 2 3 4
# 18 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 27 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
# 1 "/usr/include/boost/config/no_tr1/memory.hpp" 1 3 4
# 21 "/usr/include/boost/config/no_tr1/memory.hpp" 3 4
# 1 "/usr/include/c++/4.8/memory" 1 3 4
# 46 "/usr/include/c++/4.8/memory" 3 4
       
# 47 "/usr/include/c++/4.8/memory" 3
# 62 "/usr/include/c++/4.8/memory" 3
# 1 "/usr/include/c++/4.8/bits/stl_algobase.h" 1 3
# 60 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
# 1 "/usr/include/c++/4.8/bits/functexcept.h" 1 3
# 40 "/usr/include/c++/4.8/bits/functexcept.h" 3
# 1 "/usr/include/c++/4.8/bits/exception_defines.h" 1 3
# 41 "/usr/include/c++/4.8/bits/functexcept.h" 2 3

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__));


}
# 61 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8/bits/cpp_type_traits.h" 1 3
# 35 "/usr/include/c++/4.8/bits/cpp_type_traits.h" 3
       
# 36 "/usr/include/c++/4.8/bits/cpp_type_traits.h" 3
# 68 "/usr/include/c++/4.8/bits/cpp_type_traits.h" 3
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;
    };
# 198 "/usr/include/c++/4.8/bits/cpp_type_traits.h" 3
  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;
    };
# 421 "/usr/include/c++/4.8/bits/cpp_type_traits.h" 3

}
# 62 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8/ext/type_traits.h" 1 3
# 32 "/usr/include/c++/4.8/ext/type_traits.h" 3
       
# 33 "/usr/include/c++/4.8/ext/type_traits.h" 3




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;
    };


}
# 63 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8/ext/numeric_traits.h" 1 3
# 32 "/usr/include/c++/4.8/ext/numeric_traits.h" 3
       
# 33 "/usr/include/c++/4.8/ext/numeric_traits.h" 3




namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{

# 54 "/usr/include/c++/4.8/ext/numeric_traits.h" 3
  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;
# 99 "/usr/include/c++/4.8/ext/numeric_traits.h" 3
  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 : 64) * 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 : 18);
      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
    };

  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
    { };


}
# 64 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3

# 1 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 1 3
# 62 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 3
       
# 63 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 3







namespace std __attribute__ ((__visibility__ ("default")))
{

# 89 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 3
  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 { };
# 116 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 3
  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;
    };
# 162 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 3
  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(); }
    };
# 232 "/usr/include/c++/4.8/bits/stl_iterator_base_types.h" 3

}
# 66 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 1 3
# 62 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 3
       
# 63 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 3


# 1 "/usr/include/c++/4.8/debug/debug.h" 1 3
# 46 "/usr/include/c++/4.8/debug/debug.h" 3
namespace std
{
  namespace __debug { }
}




namespace __gnu_debug
{
  using namespace std::__debug;
}
# 66 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 2 3

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;
    }
# 112 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 3
  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;
    }
# 171 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 3
  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));
    }
# 202 "/usr/include/c++/4.8/bits/stl_iterator_base_funcs.h" 3

}
# 67 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_iterator.h" 1 3
# 67 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 95 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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; }
# 159 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      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); }
    };
# 289 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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(); }
# 401 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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) { }
# 428 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_back(__value);
 return *this;
      }
# 451 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator*()
      { return *this; }


      back_insert_iterator&
      operator++()
      { return *this; }


      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 477 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  template<typename _Container>
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 492 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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) { }
# 518 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_front(__value);
 return *this;
      }
# 541 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      front_insert_iterator&
      operator*()
      { return *this; }


      front_insert_iterator&
      operator++()
      { return *this; }


      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 567 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  template<typename _Container>
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 586 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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) {}
# 629 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }
# 655 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
      insert_iterator&
      operator*()
      { return *this; }


      insert_iterator&
      operator++()
      { return *this; }


      insert_iterator&
      operator++(int)
      { return *this; }
    };
# 681 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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")))
{

# 705 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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; }
    };
# 803 "/usr/include/c++/4.8/bits/stl_iterator.h" 3
  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); }


}
# 68 "/usr/include/c++/4.8/bits/stl_algobase.h" 2 3




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);
        }
    };
# 117 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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);



    }
# 163 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
    }
# 191 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {

     

      if (__b < __a)
 return __b;
      return __a;
    }
# 214 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {

     

      if (__a < __b)
 return __b;
      return __a;
    }
# 237 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
    }
# 258 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
 }
    };
# 325 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
 }
    };
# 363 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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)));
    }
# 448 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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));
    }
# 500 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
 }
    };
# 528 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
 }
    };
# 558 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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)));
    }
# 617 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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));
    }
# 675 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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);
    }
# 719 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
    }
# 779 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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<_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);
    }
# 941 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {




      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;
    }



  inline int
  __lg(int __n)
  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }

  inline unsigned
  __lg(unsigned __n)
  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }

  inline long
  __lg(long __n)
  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }

  inline unsigned long
  __lg(unsigned 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); }

  inline unsigned long long
  __lg(unsigned long long __n)
  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }




# 1019 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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));
    }
# 1051 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
    }
# 1082 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {





     
     
     
     
      ;
      ;

      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
      std::__niter_base(__last1),
      std::__niter_base(__first2),
      std::__niter_base(__last2));
    }
# 1118 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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;
    }
# 1158 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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);
    }
# 1195 "/usr/include/c++/4.8/bits/stl_algobase.h" 3
  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);
    }


}
# 63 "/usr/include/c++/4.8/memory" 2 3
# 1 "/usr/include/c++/4.8/bits/allocator.h" 1 3
# 46 "/usr/include/c++/4.8/bits/allocator.h" 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++allocator.h" 1 3
# 33 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++allocator.h" 3
# 1 "/usr/include/c++/4.8/ext/new_allocator.h" 1 3
# 33 "/usr/include/c++/4.8/ext/new_allocator.h" 3
# 1 "/usr/include/c++/4.8/new" 1 3
# 37 "/usr/include/c++/4.8/new" 3
       
# 38 "/usr/include/c++/4.8/new" 3


# 1 "/usr/include/c++/4.8/exception" 1 3
# 33 "/usr/include/c++/4.8/exception" 3
       
# 34 "/usr/include/c++/4.8/exception" 3

#pragma GCC visibility push(default)


# 1 "/usr/include/c++/4.8/bits/atomic_lockfree_defines.h" 1 3
# 33 "/usr/include/c++/4.8/bits/atomic_lockfree_defines.h" 3
       
# 34 "/usr/include/c++/4.8/bits/atomic_lockfree_defines.h" 3
# 39 "/usr/include/c++/4.8/exception" 2 3

extern "C++" {

namespace std
{
# 60 "/usr/include/c++/4.8/exception" 3
  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__));
# 117 "/usr/include/c++/4.8/exception" 3
  bool uncaught_exception() throw() __attribute__ ((__pure__));


}

namespace __gnu_cxx
{

# 142 "/usr/include/c++/4.8/exception" 3
  void __verbose_terminate_handler();


}

}

#pragma GCC visibility pop
# 41 "/usr/include/c++/4.8/new" 2 3

#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();
}
# 91 "/usr/include/c++/4.8/new" 3
void* operator new(std::size_t) throw(std::bad_alloc)
  __attribute__((__externally_visible__));
void* operator new[](std::size_t) throw(std::bad_alloc)
  __attribute__((__externally_visible__));
void operator delete(void*) throw()
  __attribute__((__externally_visible__));
void operator delete[](void*) throw()
  __attribute__((__externally_visible__));
void* operator new(std::size_t, const std::nothrow_t&) throw()
  __attribute__((__externally_visible__));
void* operator new[](std::size_t, const std::nothrow_t&) throw()
  __attribute__((__externally_visible__));
void operator delete(void*, const std::nothrow_t&) throw()
  __attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) throw()
  __attribute__((__externally_visible__));


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
# 34 "/usr/include/c++/4.8/ext/new_allocator.h" 2 3






namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


  using std::size_t;
  using std::ptrdiff_t;
# 57 "/usr/include/c++/4.8/ext/new_allocator.h" 3
  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); }
# 128 "/usr/include/c++/4.8/ext/new_allocator.h" 3
      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; }


}
# 34 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++allocator.h" 2 3
# 47 "/usr/include/c++/4.8/bits/allocator.h" 2 3
# 1 "/usr/include/c++/4.8/bits/memoryfwd.h" 1 3
# 46 "/usr/include/c++/4.8/bits/memoryfwd.h" 3
       
# 47 "/usr/include/c++/4.8/bits/memoryfwd.h" 3



namespace std __attribute__ ((__visibility__ ("default")))
{

# 63 "/usr/include/c++/4.8/bits/memoryfwd.h" 3
  template<typename>
    class allocator;

  template<>
    class allocator<void>;


  template<typename, typename>
    struct uses_allocator;




}
# 48 "/usr/include/c++/4.8/bits/allocator.h" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{








  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; };






    };
# 91 "/usr/include/c++/4.8/bits/allocator.h" 3
  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; }
    };
# 218 "/usr/include/c++/4.8/bits/allocator.h" 3

}
# 64 "/usr/include/c++/4.8/memory" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_construct.h" 1 3
# 61 "/usr/include/c++/4.8/bits/stl_construct.h" 3
# 1 "/usr/include/c++/4.8/ext/alloc_traits.h" 1 3
# 32 "/usr/include/c++/4.8/ext/alloc_traits.h" 3
       
# 33 "/usr/include/c++/4.8/ext/alloc_traits.h" 3
# 41 "/usr/include/c++/4.8/ext/alloc_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{

# 120 "/usr/include/c++/4.8/ext/alloc_traits.h" 3
template<typename _Alloc>
  struct __alloc_traits



  {
    typedef _Alloc allocator_type;
# 199 "/usr/include/c++/4.8/ext/alloc_traits.h" 3
    typedef typename _Alloc::pointer pointer;
    typedef typename _Alloc::const_pointer const_pointer;
    typedef typename _Alloc::value_type value_type;
    typedef typename _Alloc::reference reference;
    typedef typename _Alloc::const_reference const_reference;
    typedef typename _Alloc::size_type size_type;
    typedef typename _Alloc::difference_type difference_type;

    static pointer
    allocate(_Alloc& __a, size_type __n)
    { return __a.allocate(__n); }

    static void deallocate(_Alloc& __a, pointer __p, size_type __n)
    { __a.deallocate(__p, __n); }

    template<typename _Tp>
      static void construct(_Alloc& __a, pointer __p, const _Tp& __arg)
      { __a.construct(__p, __arg); }

    static void destroy(_Alloc& __a, pointer __p)
    { __a.destroy(__p); }

    static size_type max_size(const _Alloc& __a)
    { return __a.max_size(); }

    static const _Alloc& _S_select_on_copy(const _Alloc& __a) { return __a; }

    static void _S_on_swap(_Alloc& __a, _Alloc& __b)
    {


      std::__alloc_swap<_Alloc>::_S_do_it(__a, __b);
    }

    template<typename _Tp>
      struct rebind
      { typedef typename _Alloc::template rebind<_Tp>::other other; };

  };


}
# 62 "/usr/include/c++/4.8/bits/stl_construct.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 77 "/usr/include/c++/4.8/bits/stl_construct.h" 3
  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 _ForwardIterator, typename _Allocator>
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator& __alloc)
    {
      typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
      for (; __first != __last; ++__first)
 __traits::destroy(__alloc, std::__addressof(*__first));
    }

  template<typename _ForwardIterator, typename _Tp>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      allocator<_Tp>&)
    {
      _Destroy(__first, __last);
    }


}
# 65 "/usr/include/c++/4.8/memory" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 1 3
# 59 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 3
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); }
    };
# 105 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 3
  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); }
    };
# 162 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 3
  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); }
    };
# 216 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 3
  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
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __first != __last; ++__first, ++__cur)
     __traits::construct(__alloc, 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 _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_if_noexcept_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
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __cur != __last; ++__cur)
     __traits::construct(__alloc, 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
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __n > 0; --__n, ++__cur)
     __traits::construct(__alloc, 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); }
# 346 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 3
  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;
 }
    }
# 653 "/usr/include/c++/4.8/bits/stl_uninitialized.h" 3

}
# 66 "/usr/include/c++/4.8/memory" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_tempbuf.h" 1 3
# 62 "/usr/include/c++/4.8/bits/stl_tempbuf.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 83 "/usr/include/c++/4.8/bits/stl_tempbuf.h" 3
  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);
    }
# 110 "/usr/include/c++/4.8/bits/stl_tempbuf.h" 3
  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 _Pointer, typename _ForwardIterator>
        static void
        __ucr(_Pointer __first, _Pointer __last,
       _ForwardIterator __seed)
        {
   if(__first == __last)
     return;

   _Pointer __cur = __first;
   try
     {
       std::_Construct(std::__addressof(*__first),
         (*__seed));
       _Pointer __prev = __cur;
       ++__cur;
       for(; __cur != __last; ++__cur, ++__prev)
  std::_Construct(std::__addressof(*__cur),
    (*__prev));
       *__seed = (*__prev);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_construct_buf_dispatch<true>
    {
      template<typename _Pointer, typename _ForwardIterator>
        static void
        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
    };
# 229 "/usr/include/c++/4.8/bits/stl_tempbuf.h" 3
  template<typename _Pointer, typename _ForwardIterator>
    inline void
    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
      _ForwardIterator __seed)
    {
      typedef typename std::iterator_traits<_Pointer>::value_type
 _ValueType;

      std::__uninitialized_construct_buf_dispatch<
        __has_trivial_constructor(_ValueType)>::
   __ucr(__first, __last, __seed);
    }

  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;
 }
    }


}
# 67 "/usr/include/c++/4.8/memory" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_raw_storage_iter.h" 1 3
# 59 "/usr/include/c++/4.8/bits/stl_raw_storage_iter.h" 3
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;
      }
    };


}
# 68 "/usr/include/c++/4.8/memory" 2 3
# 87 "/usr/include/c++/4.8/memory" 3
# 1 "/usr/include/c++/4.8/backward/auto_ptr.h" 1 3
# 36 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 47 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } ;
# 86 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
  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) { }
# 112 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 124 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 135 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 152 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 170 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 180 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      element_type&
      operator*() const throw()
      {
 ;
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 ;
 return _M_ptr;
      }
# 210 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 224 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 239 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 260 "/usr/include/c++/4.8/backward/auto_ptr.h" 3
      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;
    } ;
# 326 "/usr/include/c++/4.8/backward/auto_ptr.h" 3

}
# 88 "/usr/include/c++/4.8/memory" 2 3
# 22 "/usr/include/boost/config/no_tr1/memory.hpp" 2 3 4
# 28 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 67 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     throw () __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     throw () __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     throw () __attribute__ ((__noreturn__));


}
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 81 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 82 "/usr/include/boost/assert.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/iostream" 1 3 4
# 36 "/usr/include/c++/4.8/iostream" 3 4
       
# 37 "/usr/include/c++/4.8/iostream" 3


# 1 "/usr/include/c++/4.8/ostream" 1 3
# 36 "/usr/include/c++/4.8/ostream" 3
       
# 37 "/usr/include/c++/4.8/ostream" 3

# 1 "/usr/include/c++/4.8/ios" 1 3
# 36 "/usr/include/c++/4.8/ios" 3
       
# 37 "/usr/include/c++/4.8/ios" 3

# 1 "/usr/include/c++/4.8/iosfwd" 1 3
# 36 "/usr/include/c++/4.8/iosfwd" 3
       
# 37 "/usr/include/c++/4.8/iosfwd" 3


# 1 "/usr/include/c++/4.8/bits/stringfwd.h" 1 3
# 37 "/usr/include/c++/4.8/bits/stringfwd.h" 3
       
# 38 "/usr/include/c++/4.8/bits/stringfwd.h" 3




namespace std __attribute__ ((__visibility__ ("default")))
{








  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;
# 86 "/usr/include/c++/4.8/bits/stringfwd.h" 3

}
# 40 "/usr/include/c++/4.8/iosfwd" 2 3
# 1 "/usr/include/c++/4.8/bits/postypes.h" 1 3
# 38 "/usr/include/c++/4.8/bits/postypes.h" 3
       
# 39 "/usr/include/c++/4.8/bits/postypes.h" 3

# 1 "/usr/include/c++/4.8/cwchar" 1 3
# 39 "/usr/include/c++/4.8/cwchar" 3
       
# 40 "/usr/include/c++/4.8/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 36 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/stdio.h" 1 3 4
# 44 "/usr/include/stdio.h" 3 4
struct _IO_FILE;



typedef struct _IO_FILE FILE;





# 64 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 37 "/usr/include/wchar.h" 2 3 4


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 40 "/usr/include/wchar.h" 2 3 4
# 51 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 353 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 52 "/usr/include/wchar.h" 2 3 4
# 82 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {

    unsigned int __wch;



    char __wchb[4];
  } __value;
} __mbstate_t;
# 104 "/usr/include/wchar.h" 3 4


typedef __mbstate_t mbstate_t;






# 132 "/usr/include/wchar.h" 3 4
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 ();





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__));
# 306 "/usr/include/wchar.h" 3 4
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 *__restrict __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 ();
# 530 "/usr/include/wchar.h" 3 4
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 () ;
# 680 "/usr/include/wchar.h" 3 4









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 () ;
# 736 "/usr/include/wchar.h" 3 4









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);

# 801 "/usr/include/wchar.h" 3 4
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);
# 827 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 837 "/usr/include/wchar.h" 3 4
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 ();
# 884 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wchar2.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/wchar2.h" 3 4
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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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 ());
}
# 303 "/usr/include/i386-linux-gnu/bits/wchar2.h" 3 4
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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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);
}
# 885 "/usr/include/wchar.h" 2 3 4






}
# 45 "/usr/include/c++/4.8/cwchar" 2 3
# 62 "/usr/include/c++/4.8/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 135 "/usr/include/c++/4.8/cwchar" 3
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;
# 232 "/usr/include/c++/4.8/cwchar" 3

}







namespace __gnu_cxx
{





  using ::wcstold;
# 257 "/usr/include/c++/4.8/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;
}
# 41 "/usr/include/c++/4.8/bits/postypes.h" 2 3
# 68 "/usr/include/c++/4.8/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 90 "/usr/include/c++/4.8/bits/postypes.h" 3
  typedef long long streamoff;







  typedef ptrdiff_t streamsize;
# 111 "/usr/include/c++/4.8/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 133 "/usr/include/c++/4.8/bits/postypes.h" 3
      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;
# 239 "/usr/include/c++/4.8/bits/postypes.h" 3

}
# 41 "/usr/include/c++/4.8/iosfwd" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 74 "/usr/include/c++/4.8/iosfwd" 3
  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;




}
# 39 "/usr/include/c++/4.8/ios" 2 3

# 1 "/usr/include/c++/4.8/bits/char_traits.h" 1 3
# 37 "/usr/include/c++/4.8/bits/char_traits.h" 3
       
# 38 "/usr/include/c++/4.8/bits/char_traits.h" 3



# 1 "/usr/include/c++/4.8/cwchar" 1 3
# 39 "/usr/include/c++/4.8/cwchar" 3
       
# 40 "/usr/include/c++/4.8/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/usr/include/c++/4.8/cwchar" 2 3
# 42 "/usr/include/c++/4.8/bits/char_traits.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{

# 57 "/usr/include/c++/4.8/bits/char_traits.h" 3
  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;
    };
# 82 "/usr/include/c++/4.8/bits/char_traits.h" 3
  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")))
{

# 226 "/usr/include/c++/4.8/bits/char_traits.h" 3
  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; }
  };



}
# 41 "/usr/include/c++/4.8/ios" 2 3
# 1 "/usr/include/c++/4.8/bits/localefwd.h" 1 3
# 37 "/usr/include/c++/4.8/bits/localefwd.h" 3
       
# 38 "/usr/include/c++/4.8/bits/localefwd.h" 3


# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++locale.h" 1 3
# 39 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++locale.h" 3
       
# 40 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++locale.h" 3

# 1 "/usr/include/c++/4.8/clocale" 1 3
# 39 "/usr/include/c++/4.8/clocale" 3
       
# 40 "/usr/include/c++/4.8/clocale" 3


# 1 "/usr/include/locale.h" 1 3 4
# 29 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/bits/locale.h" 1 3 4
# 31 "/usr/include/locale.h" 2 3 4

extern "C" {
# 51 "/usr/include/locale.h" 3 4



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;
# 121 "/usr/include/locale.h" 3 4
};



extern char *setlocale (int __category, const char *__locale) throw ();


extern struct lconv *localeconv (void) throw ();


# 152 "/usr/include/locale.h" 3 4
extern __locale_t newlocale (int __category_mask, const char *__locale,
        __locale_t __base) throw ();
# 187 "/usr/include/locale.h" 3 4
extern __locale_t duplocale (__locale_t __dataset) throw ();



extern void freelocale (__locale_t __dataset) throw ();






extern __locale_t uselocale (__locale_t __dataset) throw ();







}
# 43 "/usr/include/c++/4.8/clocale" 2 3
# 51 "/usr/include/c++/4.8/clocale" 3
namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++locale.h" 2 3






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);
# 88 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++locale.h" 3
    __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;
  }


}
# 41 "/usr/include/c++/4.8/bits/localefwd.h" 2 3

# 1 "/usr/include/c++/4.8/cctype" 1 3
# 39 "/usr/include/c++/4.8/cctype" 3
       
# 40 "/usr/include/c++/4.8/cctype" 3


# 1 "/usr/include/ctype.h" 1 3 4
# 29 "/usr/include/ctype.h" 3 4
extern "C" {
# 47 "/usr/include/ctype.h" 3 4
enum
{
  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 80 "/usr/include/ctype.h" 3 4
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__));
# 105 "/usr/include/ctype.h" 3 4






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 ();
# 272 "/usr/include/ctype.h" 3 4
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 ();
# 348 "/usr/include/ctype.h" 3 4
}
# 43 "/usr/include/c++/4.8/cctype" 2 3
# 62 "/usr/include/c++/4.8/cctype" 3
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;
}
# 43 "/usr/include/c++/4.8/bits/localefwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 55 "/usr/include/c++/4.8/bits/localefwd.h" 3
  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;



  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;

  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;


}
# 42 "/usr/include/c++/4.8/ios" 2 3
# 1 "/usr/include/c++/4.8/bits/ios_base.h" 1 3
# 37 "/usr/include/c++/4.8/bits/ios_base.h" 3
       
# 38 "/usr/include/c++/4.8/bits/ios_base.h" 3

# 1 "/usr/include/c++/4.8/ext/atomicity.h" 1 3
# 33 "/usr/include/c++/4.8/ext/atomicity.h" 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr.h" 1 3
# 30 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 148 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr.h" 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 1 3
# 35 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
# 1 "/usr/include/pthread.h" 1 3 4
# 23 "/usr/include/pthread.h" 3 4
# 1 "/usr/include/sched.h" 1 3 4
# 29 "/usr/include/sched.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 30 "/usr/include/sched.h" 2 3 4



# 1 "/usr/include/time.h" 1 3 4
# 34 "/usr/include/sched.h" 2 3 4
# 42 "/usr/include/sched.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/sched.h" 1 3 4
# 73 "/usr/include/i386-linux-gnu/bits/sched.h" 3 4
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;
  };
# 119 "/usr/include/i386-linux-gnu/bits/sched.h" 3 4
typedef unsigned long int __cpu_mask;






typedef struct
{
  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
} cpu_set_t;
# 202 "/usr/include/i386-linux-gnu/bits/sched.h" 3 4
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 ();

}
# 43 "/usr/include/sched.h" 2 3 4




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 ();
# 117 "/usr/include/sched.h" 3 4
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 ();


}
# 24 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/time.h" 1 3 4
# 29 "/usr/include/time.h" 3 4
extern "C" {







# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 38 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/i386-linux-gnu/bits/time.h" 1 3 4
# 86 "/usr/include/i386-linux-gnu/bits/time.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/timex.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/bits/timex.h" 3 4
struct timex
{
  unsigned int modes;
  __syscall_slong_t offset;
  __syscall_slong_t freq;
  __syscall_slong_t maxerror;
  __syscall_slong_t esterror;
  int status;
  __syscall_slong_t constant;
  __syscall_slong_t precision;
  __syscall_slong_t tolerance;
  struct timeval time;
  __syscall_slong_t tick;
  __syscall_slong_t ppsfreq;
  __syscall_slong_t jitter;
  int shift;
  __syscall_slong_t stabil;
  __syscall_slong_t jitcnt;
  __syscall_slong_t calcnt;
  __syscall_slong_t errcnt;
  __syscall_slong_t 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;
};
# 87 "/usr/include/i386-linux-gnu/bits/time.h" 2 3 4

extern "C" {


extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) throw ();

}
# 42 "/usr/include/time.h" 2 3 4
# 131 "/usr/include/time.h" 3 4


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;
# 186 "/usr/include/time.h" 3 4



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 ();
# 319 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) throw ();


extern time_t timelocal (struct tm *__tp) throw ();


extern int dysize (int __year) throw () __attribute__ ((__const__));
# 334 "/usr/include/time.h" 3 4
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 timespec_get (struct timespec *__ts, int __base)
     throw () __attribute__ ((__nonnull__ (1)));
# 403 "/usr/include/time.h" 3 4
extern int getdate_err;
# 412 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 426 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
        struct tm *__restrict __resbufp);


}
# 25 "/usr/include/pthread.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/setjmp.h" 1 3 4
# 26 "/usr/include/i386-linux-gnu/bits/setjmp.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 27 "/usr/include/i386-linux-gnu/bits/setjmp.h" 2 3 4
# 35 "/usr/include/i386-linux-gnu/bits/setjmp.h" 3 4
typedef int __jmp_buf[6];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 29 "/usr/include/pthread.h" 2 3 4



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
};
# 113 "/usr/include/pthread.h" 3 4
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
};
# 154 "/usr/include/pthread.h" 3 4
enum
{
  PTHREAD_INHERIT_SCHED,

  PTHREAD_EXPLICIT_SCHED

};



enum
{
  PTHREAD_SCOPE_SYSTEM,

  PTHREAD_SCOPE_PROCESS

};



enum
{
  PTHREAD_PROCESS_PRIVATE,

  PTHREAD_PROCESS_SHARED

};
# 189 "/usr/include/pthread.h" 3 4
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

};
# 227 "/usr/include/pthread.h" 3 4
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 () __attribute__ ((__const__));







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)));
# 485 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 497 "/usr/include/pthread.h" 3 4
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__));
# 531 "/usr/include/pthread.h" 3 4
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); }
};
# 733 "/usr/include/pthread.h" 3 4
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)));
# 797 "/usr/include/pthread.h" 3 4
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)));
# 879 "/usr/include/pthread.h" 3 4
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)));
# 991 "/usr/include/pthread.h" 3 4
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)));
# 1035 "/usr/include/pthread.h" 3 4
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)));
# 1102 "/usr/include/pthread.h" 3 4
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)));
# 1136 "/usr/include/pthread.h" 3 4
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;
}


}
# 36 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 2 3
# 47 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
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;
# 101 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
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_init) __gthrw_pthread_cond_init __attribute__ ((__weakref__("pthread_cond_init")));
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")));
# 236 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
# 246 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr
    = __extension__ (void *) &__gthrw___pthread_key_create;
  return __gthread_active_ptr != 0;
}
# 658 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
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 void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    __gthrw_pthread_mutex_init (__mutex, __null);
}

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;
}
# 807 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
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_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex)
{
  return __gthread_mutex_destroy (__mutex);
}
# 849 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr-default.h" 3
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_destroy (__gthread_cond_t* __cond)
{
  return __gthrw_pthread_cond_destroy (__cond);
}
# 149 "/usr/include/i386-linux-gnu/c++/4.8/bits/gthr.h" 2 3


#pragma GCC visibility pop
# 34 "/usr/include/c++/4.8/ext/atomicity.h" 2 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/atomic_word.h" 1 3
# 32 "/usr/include/i386-linux-gnu/c++/4.8/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 35 "/usr/include/c++/4.8/ext/atomicity.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{







  static inline _Atomic_word
  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
  { return __atomic_fetch_add(__mem, __val, 4); }

  static inline void
  __atomic_add(volatile _Atomic_word* __mem, int __val)
  { __atomic_fetch_add(__mem, __val, 4); }
# 62 "/usr/include/c++/4.8/ext/atomicity.h" 3
  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);



  }


}
# 40 "/usr/include/c++/4.8/bits/ios_base.h" 2 3

# 1 "/usr/include/c++/4.8/bits/locale_classes.h" 1 3
# 37 "/usr/include/c++/4.8/bits/locale_classes.h" 3
       
# 38 "/usr/include/c++/4.8/bits/locale_classes.h" 3


# 1 "/usr/include/c++/4.8/string" 1 3
# 36 "/usr/include/c++/4.8/string" 3
       
# 37 "/usr/include/c++/4.8/string" 3







# 1 "/usr/include/c++/4.8/bits/ostream_insert.h" 1 3
# 33 "/usr/include/c++/4.8/bits/ostream_insert.h" 3
       
# 34 "/usr/include/c++/4.8/bits/ostream_insert.h" 3


# 1 "/usr/include/c++/4.8/bits/cxxabi_forced.h" 1 3
# 34 "/usr/include/c++/4.8/bits/cxxabi_forced.h" 3
       
# 35 "/usr/include/c++/4.8/bits/cxxabi_forced.h" 3

#pragma GCC visibility push(default)


namespace __cxxabiv1
{







  class __forced_unwind
  {
    virtual ~__forced_unwind() throw();


    virtual void __pure_dummy() = 0;
  };
}


#pragma GCC visibility pop
# 37 "/usr/include/c++/4.8/bits/ostream_insert.h" 2 3

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);




}
# 45 "/usr/include/c++/4.8/string" 2 3



# 1 "/usr/include/c++/4.8/bits/stl_function.h" 1 3
# 59 "/usr/include/c++/4.8/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 100 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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;
    };
# 139 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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; }
    };
# 203 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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; }
    };
# 267 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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; }
    };
# 350 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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); }
# 421 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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; }
# 508 "/usr/include/c++/4.8/bits/stl_function.h" 3
    };

  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; }
    };
# 541 "/usr/include/c++/4.8/bits/stl_function.h" 3
  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); }




}


# 1 "/usr/include/c++/4.8/backward/binders.h" 1 3
# 59 "/usr/include/c++/4.8/backward/binders.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 103 "/usr/include/c++/4.8/backward/binders.h" 3
  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));
    }



}
# 732 "/usr/include/c++/4.8/bits/stl_function.h" 2 3
# 49 "/usr/include/c++/4.8/string" 2 3


# 1 "/usr/include/c++/4.8/bits/range_access.h" 1 3
# 33 "/usr/include/c++/4.8/bits/range_access.h" 3
       
# 34 "/usr/include/c++/4.8/bits/range_access.h" 3
# 52 "/usr/include/c++/4.8/string" 2 3
# 1 "/usr/include/c++/4.8/bits/basic_string.h" 1 3
# 37 "/usr/include/c++/4.8/bits/basic_string.h" 3
       
# 38 "/usr/include/c++/4.8/bits/basic_string.h" 3







namespace std __attribute__ ((__visibility__ ("default")))
{

# 111 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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:
# 148 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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;
# 173 "/usr/include/c++/4.8/bits/basic_string.h" 3
 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);
# 483 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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());
# 531 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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); }
# 564 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 604 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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()); }
# 710 "/usr/include/c++/4.8/bits/basic_string.h" 3
    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; }
# 739 "/usr/include/c++/4.8/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 752 "/usr/include/c++/4.8/bits/basic_string.h" 3
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }
# 775 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      capacity() const
      { return _M_rep()->_M_capacity; }
# 796 "/usr/include/c++/4.8/bits/basic_string.h" 3
      void
      reserve(size_type __res_arg = 0);




      void
      clear()
      { _M_mutate(0, this->size(), 0); }





      bool
      empty() const
      { return this->size() == 0; }
# 825 "/usr/include/c++/4.8/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const
      {
 ;
 return _M_data()[__pos];
      }
# 842 "/usr/include/c++/4.8/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {

 ;

 ;
 _M_leak();
 return _M_data()[__pos];
      }
# 863 "/usr/include/c++/4.8/bits/basic_string.h" 3
      const_reference
      at(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range(("basic_string::at"));
 return _M_data()[__n];
      }
# 882 "/usr/include/c++/4.8/bits/basic_string.h" 3
      reference
      at(size_type __n)
      {
 if (__n >= size())
   __throw_out_of_range(("basic_string::at"));
 _M_leak();
 return _M_data()[__n];
      }
# 931 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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;
      }
# 972 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str);
# 988 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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));
      }
# 1020 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c);
# 1042 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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);
# 1099 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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)); }
# 1115 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n);
# 1127 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
 ;
 return this->assign(__s, traits_type::length(__s));
      }
# 1143 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1155 "/usr/include/c++/4.8/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
# 1184 "/usr/include/c++/4.8/bits/basic_string.h" 3
      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }
# 1200 "/usr/include/c++/4.8/bits/basic_string.h" 3
      template<class _InputIterator>
        void
        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }
# 1232 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
# 1254 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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)); }
# 1277 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);
# 1295 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
 ;
 return this->insert(__pos, __s, traits_type::length(__s));
      }
# 1318 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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); }
# 1336 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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);
      }
# 1361 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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;
      }
# 1377 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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);
      }
# 1397 "/usr/include/c++/4.8/bits/basic_string.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1428 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 1450 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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)); }
# 1475 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2);
# 1495 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
 ;
 return this->replace(__pos, __n1, __s, traits_type::length(__s));
      }
# 1519 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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); }
# 1537 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 1556 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
      {

                          ;
 return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
      }
# 1577 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, const _CharT* __s)
      {
 ;
 return this->replace(__i1, __i2, __s, traits_type::length(__s));
      }
# 1598 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string&
      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
      {

                          ;
 return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
      }
# 1621 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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);
      }
# 1697 "/usr/include/c++/4.8/bits/basic_string.h" 3
    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:
# 1779 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1789 "/usr/include/c++/4.8/bits/basic_string.h" 3
      void
      swap(basic_string& __s);
# 1799 "/usr/include/c++/4.8/bits/basic_string.h" 3
      const _CharT*
      c_str() const
      { return _M_data(); }







      const _CharT*
      data() const
      { return _M_data(); }




      allocator_type
      get_allocator() const
      { return _M_dataplus; }
# 1832 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;
# 1845 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find(const basic_string& __str, size_type __pos = 0) const

      { return this->find(__str.data(), __pos, __str.size()); }
# 1860 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find(__s, __pos, traits_type::length(__s));
      }
# 1877 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const ;
# 1890 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const

      { return this->rfind(__str.data(), __pos, __str.size()); }
# 1907 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 1920 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->rfind(__s, __pos, traits_type::length(__s));
      }
# 1937 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const ;
# 1951 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const

      { return this->find_first_of(__str.data(), __pos, __str.size()); }
# 1968 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1981 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      {
 ;
 return this->find_first_of(__s, __pos, traits_type::length(__s));
      }
# 2000 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }
# 2015 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const

      { return this->find_last_of(__str.data(), __pos, __str.size()); }
# 2032 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 2045 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      {
 ;
 return this->find_last_of(__s, __pos, traits_type::length(__s));
      }
# 2064 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }
# 2078 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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()); }
# 2095 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const;
# 2109 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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));
      }
# 2126 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const
 ;
# 2141 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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()); }
# 2158 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const;
# 2172 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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));
      }
# 2189 "/usr/include/c++/4.8/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const
 ;
# 2205 "/usr/include/c++/4.8/bits/basic_string.h" 3
      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      { return basic_string(*this,
       _M_check(__pos, "basic_string::substr"), __n); }
# 2224 "/usr/include/c++/4.8/bits/basic_string.h" 3
      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;
      }
# 2256 "/usr/include/c++/4.8/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2282 "/usr/include/c++/4.8/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2) const;
# 2300 "/usr/include/c++/4.8/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const;
# 2324 "/usr/include/c++/4.8/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2351 "/usr/include/c++/4.8/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const;
  };
# 2363 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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;
    }
# 2484 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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; }
# 2530 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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); }
# 2567 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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; }
# 2604 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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; }
# 2641 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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; }
# 2678 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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; }
# 2715 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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); }
# 2733 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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);
# 2751 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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());
    }
# 2774 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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);
# 2791 "/usr/include/c++/4.8/bits/basic_string.h" 3
  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);



}
# 53 "/usr/include/c++/4.8/string" 2 3
# 1 "/usr/include/c++/4.8/bits/basic_string.tcc" 1 3
# 40 "/usr/include/c++/4.8/bits/basic_string.tcc" 3
       
# 41 "/usr/include/c++/4.8/bits/basic_string.tcc" 3



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)
    { }
# 240 "/usr/include/c++/4.8/bits/basic_string.tcc" 3
  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"));
# 577 "/usr/include/c++/4.8/bits/basic_string.tcc" 3
      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&);




}
# 54 "/usr/include/c++/4.8/string" 2 3
# 41 "/usr/include/c++/4.8/bits/locale_classes.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{

# 62 "/usr/include/c++/4.8/bits/locale_classes.h" 3
  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;
# 98 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    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);
# 117 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    locale() throw();
# 126 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 136 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 151 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 164 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 177 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 191 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 206 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    template<typename _Facet>
      locale
      combine(const locale& __other) const;






    string
    name() const;
# 225 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    bool
    operator==(const locale& __other) const throw();







    bool
    operator!=(const locale& __other) const throw()
    { return !(this->operator==(__other)); }
# 253 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 269 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    static locale
    global(const locale& __loc);




    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 304 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    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);
  };
# 338 "/usr/include/c++/4.8/bits/locale_classes.h" 3
  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:
# 369 "/usr/include/c++/4.8/bits/locale_classes.h" 3
    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&);
  };
# 436 "/usr/include/c++/4.8/bits/locale_classes.h" 3
  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);
  };
# 583 "/usr/include/c++/4.8/bits/locale_classes.h" 3
  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;
# 610 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 624 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 641 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
       const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 660 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 674 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      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); }
# 703 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 717 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 730 "/usr/include/c++/4.8/bits/locale_classes.h" 3
      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() { }
    };


}

# 1 "/usr/include/c++/4.8/bits/locale_classes.tcc" 1 3
# 37 "/usr/include/c++/4.8/bits/locale_classes.tcc" 3
       
# 38 "/usr/include/c++/4.8/bits/locale_classes.tcc" 3

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);
    }
# 102 "/usr/include/c++/4.8/bits/locale_classes.tcc" 3
  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]));



    }
# 130 "/usr/include/c++/4.8/bits/locale_classes.tcc" 3
  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&);




}
# 788 "/usr/include/c++/4.8/bits/locale_classes.h" 2 3
# 42 "/usr/include/c++/4.8/bits/ios_base.h" 2 3

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
    };
# 199 "/usr/include/c++/4.8/bits/ios_base.h" 3
  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;
    };
# 255 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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;
# 330 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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;
# 361 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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;
# 393 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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;
# 419 "/usr/include/c++/4.8/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 436 "/usr/include/c++/4.8/bits/ios_base.h" 3
    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 448 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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; }
# 561 "/usr/include/c++/4.8/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 577 "/usr/include/c++/4.8/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 594 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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; }
# 620 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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;
    }
# 671 "/usr/include/c++/4.8/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 683 "/usr/include/c++/4.8/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc) throw();
# 694 "/usr/include/c++/4.8/bits/ios_base.h" 3
    locale
    getloc() const
    { return _M_ios_locale; }
# 705 "/usr/include/c++/4.8/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 724 "/usr/include/c++/4.8/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 740 "/usr/include/c++/4.8/bits/ios_base.h" 3
    long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 761 "/usr/include/c++/4.8/bits/ios_base.h" 3
    void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 778 "/usr/include/c++/4.8/bits/ios_base.h" 3
    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;
  }


}
# 43 "/usr/include/c++/4.8/ios" 2 3
# 1 "/usr/include/c++/4.8/streambuf" 1 3
# 36 "/usr/include/c++/4.8/streambuf" 3
       
# 37 "/usr/include/c++/4.8/streambuf" 3
# 45 "/usr/include/c++/4.8/streambuf" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
     basic_streambuf<_CharT, _Traits>*, bool&);
# 119 "/usr/include/c++/4.8/streambuf" 3
  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<>(basic_streambuf*, basic_streambuf*, 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()
      { }
# 208 "/usr/include/c++/4.8/streambuf" 3
      locale
      pubimbue(const locale& __loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 225 "/usr/include/c++/4.8/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 238 "/usr/include/c++/4.8/streambuf" 3
      basic_streambuf*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }
# 250 "/usr/include/c++/4.8/streambuf" 3
      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); }
# 262 "/usr/include/c++/4.8/streambuf" 3
      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(); }
# 283 "/usr/include/c++/4.8/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 297 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 315 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 337 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 356 "/usr/include/c++/4.8/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 371 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 396 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 423 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 449 "/usr/include/c++/4.8/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 463 "/usr/include/c++/4.8/streambuf" 3
      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())
      { }
# 481 "/usr/include/c++/4.8/streambuf" 3
      char_type*
      eback() const { return _M_in_beg; }

      char_type*
      gptr() const { return _M_in_cur; }

      char_type*
      egptr() const { return _M_in_end; }
# 497 "/usr/include/c++/4.8/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 508 "/usr/include/c++/4.8/streambuf" 3
      void
      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
      {
 _M_in_beg = __gbeg;
 _M_in_cur = __gnext;
 _M_in_end = __gend;
      }
# 528 "/usr/include/c++/4.8/streambuf" 3
      char_type*
      pbase() const { return _M_out_beg; }

      char_type*
      pptr() const { return _M_out_cur; }

      char_type*
      epptr() const { return _M_out_end; }
# 544 "/usr/include/c++/4.8/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 554 "/usr/include/c++/4.8/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 575 "/usr/include/c++/4.8/streambuf" 3
      virtual void
      imbue(const locale& __loc)
      { }
# 590 "/usr/include/c++/4.8/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 601 "/usr/include/c++/4.8/streambuf" 3
      virtual pos_type
      seekoff(off_type, ios_base::seekdir,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 613 "/usr/include/c++/4.8/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 626 "/usr/include/c++/4.8/streambuf" 3
      virtual int
      sync() { return 0; }
# 648 "/usr/include/c++/4.8/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 664 "/usr/include/c++/4.8/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 686 "/usr/include/c++/4.8/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 699 "/usr/include/c++/4.8/streambuf" 3
      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;
      }
# 723 "/usr/include/c++/4.8/streambuf" 3
      virtual int_type
      pbackfail(int_type __c = traits_type::eof())
      { return traits_type::eof(); }
# 741 "/usr/include/c++/4.8/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 767 "/usr/include/c++/4.8/streambuf" 3
      virtual int_type
      overflow(int_type __c = traits_type::eof())
      { return traits_type::eof(); }



    public:
# 782 "/usr/include/c++/4.8/streambuf" 3
      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 basic_streambuf& __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)
      { }

      basic_streambuf&
      operator=(const basic_streambuf&) { 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);



}

# 1 "/usr/include/c++/4.8/bits/streambuf.tcc" 1 3
# 37 "/usr/include/c++/4.8/bits/streambuf.tcc" 3
       
# 38 "/usr/include/c++/4.8/bits/streambuf.tcc" 3

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&);




}
# 829 "/usr/include/c++/4.8/streambuf" 2 3
# 44 "/usr/include/c++/4.8/ios" 2 3
# 1 "/usr/include/c++/4.8/bits/basic_ios.h" 1 3
# 33 "/usr/include/c++/4.8/bits/basic_ios.h" 3
       
# 34 "/usr/include/c++/4.8/bits/basic_ios.h" 3



# 1 "/usr/include/c++/4.8/bits/locale_facets.h" 1 3
# 37 "/usr/include/c++/4.8/bits/locale_facets.h" 3
       
# 38 "/usr/include/c++/4.8/bits/locale_facets.h" 3

# 1 "/usr/include/c++/4.8/cwctype" 1 3
# 39 "/usr/include/c++/4.8/cwctype" 3
       
# 40 "/usr/include/c++/4.8/cwctype" 3
# 50 "/usr/include/c++/4.8/cwctype" 3
# 1 "/usr/include/wctype.h" 1 3 4
# 33 "/usr/include/wctype.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 34 "/usr/include/wctype.h" 2 3 4
# 49 "/usr/include/wctype.h" 3 4



typedef unsigned long int wctype_t;

# 71 "/usr/include/wctype.h" 3 4
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 = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
};



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 ();
# 171 "/usr/include/wctype.h" 3 4
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 ();


}
# 213 "/usr/include/wctype.h" 3 4
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 ();



}
# 51 "/usr/include/c++/4.8/cwctype" 2 3
# 80 "/usr/include/c++/4.8/cwctype" 3
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;
}
# 40 "/usr/include/c++/4.8/bits/locale_facets.h" 2 3
# 1 "/usr/include/c++/4.8/cctype" 1 3
# 39 "/usr/include/c++/4.8/cctype" 3
       
# 40 "/usr/include/c++/4.8/cctype" 3
# 41 "/usr/include/c++/4.8/bits/locale_facets.h" 2 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/ctype_base.h" 1 3
# 36 "/usr/include/i386-linux-gnu/c++/4.8/bits/ctype_base.h" 3
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;
  };


}
# 42 "/usr/include/c++/4.8/bits/locale_facets.h" 2 3






# 1 "/usr/include/c++/4.8/bits/streambuf_iterator.h" 1 3
# 33 "/usr/include/c++/4.8/bits/streambuf_iterator.h" 3
       
# 34 "/usr/include/c++/4.8/bits/streambuf_iterator.h" 3




namespace std __attribute__ ((__visibility__ ("default")))
{

# 49 "/usr/include/c++/4.8/bits/streambuf_iterator.h" 3
  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()) { }
# 112 "/usr/include/c++/4.8/bits/streambuf_iterator.h" 3
      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;
    }




}
# 49 "/usr/include/c++/4.8/bits/locale_facets.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 64 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  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;
    }
# 142 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 161 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 178 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }
# 194 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }
# 210 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }
# 224 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 239 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 253 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 268 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 285 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 304 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }
# 323 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 345 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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() { }
# 370 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 389 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 408 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 427 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 445 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const = 0;
# 462 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 478 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const = 0;
# 495 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 514 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const = 0;
# 535 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
# 556 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const = 0;
# 581 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const = 0;
    };
# 604 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  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* __to) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;
# 673 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  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);
# 710 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 723 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 736 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 751 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 765 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 779 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 794 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 811 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 827 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 844 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 864 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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);
      }
# 891 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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);
      }
# 922 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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;
      }
# 955 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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();
# 1004 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1021 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1037 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1054 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1074 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1097 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 __builtin_memcpy(__to, __lo, __hi - __lo);
 return __hi;
      }
# 1123 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const
      { return __c; }
# 1149 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const
      {
 __builtin_memcpy(__to, __lo, __hi - __lo);
 return __hi;
      }

    private:
      void _M_narrow_init() const;
      void _M_widen_init() const;
    };
# 1174 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  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;
# 1207 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1218 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, size_t __refs = 0);

    protected:
      __wmask_type
      _M_convert_to_wmask(const mask __m) const throw();


      virtual
      ~ctype();
# 1242 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1261 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1279 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1297 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1314 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1331 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1347 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1364 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1384 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const;
# 1406 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
# 1429 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const;
# 1455 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) 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();
    };



}


# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/ctype_inline.h" 1 3
# 37 "/usr/include/i386-linux-gnu/c++/4.8/bits/ctype_inline.h" 3
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;
  }


}
# 1512 "/usr/include/c++/4.8/bits/locale_facets.h" 2 3

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;
 }
    }
# 1640 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  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(); }
# 1678 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1692 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_numpunct(__cloc); }
# 1706 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1719 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1750 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1763 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1776 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1793 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1805 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1818 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1831 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1844 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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() { }
    };


# 1914 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 1935 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1961 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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); }
# 1998 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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); }
# 2058 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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); }
# 2101 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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;
 }
# 2172 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      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&, float&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      double&) const;







      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      long double&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
# 2235 "/usr/include/c++/4.8/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2253 "/usr/include/c++/4.8/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 2274 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2292 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2334 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   unsigned long __v) const
      { return this->do_put(__s, __io, __fill, __v); }


      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   unsigned long long __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2397 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   long double __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2422 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const void* __v) const
      { return this->do_put(__s, __io, __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() { };
# 2470 "/usr/include/c++/4.8/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, 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, double) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type, long double) const;


      virtual iter_type
      do_put(iter_type, ios_base&, char_type, const void*) 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); }


}

# 1 "/usr/include/c++/4.8/bits/locale_facets.tcc" 1 3
# 33 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
       
# 34 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3

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;
 }
    }
# 136 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
  __attribute__ ((__pure__)) bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp) throw ();



  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;
    }
# 730 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
  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;
    }



  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;
    }
# 966 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
  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);
   }
# 1027 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
 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); }
# 1152 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
  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;
    }


# 1189 "/usr/include/c++/4.8/bits/locale_facets.tcc" 3
  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 num_get<char>;
  extern template class 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 num_get<wchar_t>;
  extern template class 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&);




}
# 2609 "/usr/include/c++/4.8/bits/locale_facets.h" 2 3
# 38 "/usr/include/c++/4.8/bits/basic_ios.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
# 65 "/usr/include/c++/4.8/bits/basic_ios.h" 3
  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(); }
# 130 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 141 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      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; }
# 194 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 215 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 250 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      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() { }
# 288 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 300 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      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; }
# 340 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 354 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      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;
      }
# 383 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 403 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 423 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 442 "/usr/include/c++/4.8/bits/basic_ios.h" 3
      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);
    };


}

# 1 "/usr/include/c++/4.8/bits/basic_ios.tcc" 1 3
# 33 "/usr/include/c++/4.8/bits/basic_ios.tcc" 3
       
# 34 "/usr/include/c++/4.8/bits/basic_ios.tcc" 3

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);
# 146 "/usr/include/c++/4.8/bits/basic_ios.tcc" 3
      _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>;




}
# 476 "/usr/include/c++/4.8/bits/basic_ios.h" 2 3
# 45 "/usr/include/c++/4.8/ios" 2 3
# 39 "/usr/include/c++/4.8/ostream" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{

# 57 "/usr/include/c++/4.8/ostream" 3
  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;
# 83 "/usr/include/c++/4.8/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 107 "/usr/include/c++/4.8/ostream" 3
      __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;
      }
# 165 "/usr/include/c++/4.8/ostream" 3
      __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); }
# 219 "/usr/include/c++/4.8/ostream" 3
      __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); }
# 244 "/usr/include/c++/4.8/ostream" 3
      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }
# 269 "/usr/include/c++/4.8/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 302 "/usr/include/c++/4.8/ostream" 3
      __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);
      }
# 334 "/usr/include/c++/4.8/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 347 "/usr/include/c++/4.8/ostream" 3
      __ostream_type&
      flush();
# 357 "/usr/include/c++/4.8/ostream" 3
      pos_type
      tellp();
# 368 "/usr/include/c++/4.8/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 380 "/usr/include/c++/4.8/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    protected:
      basic_ostream()
      { this->init(0); }

      template<typename _ValueT>
 __ostream_type&
 _M_insert(_ValueT __v);
    };
# 399 "/usr/include/c++/4.8/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT, _Traits>& _M_os;

    public:
# 418 "/usr/include/c++/4.8/ostream" 3
      explicit
      sentry(basic_ostream<_CharT, _Traits>& __os);
# 428 "/usr/include/c++/4.8/ostream" 3
      ~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);
   }
      }
# 449 "/usr/include/c++/4.8/ostream" 3
      operator bool() const
      { return _M_ok; }
    };
# 469 "/usr/include/c++/4.8/ostream" 3
  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)); }
# 511 "/usr/include/c++/4.8/ostream" 3
  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)); }
# 562 "/usr/include/c++/4.8/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }
# 574 "/usr/include/c++/4.8/ostream" 3
  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(); }
# 606 "/usr/include/c++/4.8/ostream" 3

}

# 1 "/usr/include/c++/4.8/bits/ostream.tcc" 1 3
# 37 "/usr/include/c++/4.8/bits/ostream.tcc" 3
       
# 38 "/usr/include/c++/4.8/bits/ostream.tcc" 3



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*);




}
# 610 "/usr/include/c++/4.8/ostream" 2 3
# 40 "/usr/include/c++/4.8/iostream" 2 3
# 1 "/usr/include/c++/4.8/istream" 1 3
# 36 "/usr/include/c++/4.8/istream" 3
       
# 37 "/usr/include/c++/4.8/istream" 3




namespace std __attribute__ ((__visibility__ ("default")))
{

# 57 "/usr/include/c++/4.8/istream" 3
  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;
# 119 "/usr/include/c++/4.8/istream" 3
      __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;
      }
# 167 "/usr/include/c++/4.8/istream" 3
      __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); }
# 213 "/usr/include/c++/4.8/istream" 3
      __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); }
# 234 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      operator>>(void*& __p)
      { return _M_extract(__p); }
# 258 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 268 "/usr/include/c++/4.8/istream" 3
      streamsize
      gcount() const
      { return _M_gcount; }
# 301 "/usr/include/c++/4.8/istream" 3
      int_type
      get();
# 315 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      get(char_type& __c);
# 342 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 353 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 376 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 386 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 415 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 426 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 450 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      ignore(streamsize __n, int_type __delim);

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore();
# 467 "/usr/include/c++/4.8/istream" 3
      int_type
      peek();
# 485 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 504 "/usr/include/c++/4.8/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 521 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      putback(char_type __c);
# 537 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      unget();
# 555 "/usr/include/c++/4.8/istream" 3
      int
      sync();
# 570 "/usr/include/c++/4.8/istream" 3
      pos_type
      tellg();
# 585 "/usr/include/c++/4.8/istream" 3
      __istream_type&
      seekg(pos_type);
# 601 "/usr/include/c++/4.8/istream" 3
      __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);
# 656 "/usr/include/c++/4.8/istream" 3
  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;
# 692 "/usr/include/c++/4.8/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 705 "/usr/include/c++/4.8/istream" 3
      operator bool() const
      { return _M_ok; }
    };
# 721 "/usr/include/c++/4.8/istream" 3
  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)); }
# 763 "/usr/include/c++/4.8/istream" 3
  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)); }
# 794 "/usr/include/c++/4.8/istream" 3
  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() { }
    };
# 854 "/usr/include/c++/4.8/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
# 876 "/usr/include/c++/4.8/istream" 3

}

# 1 "/usr/include/c++/4.8/bits/istream.tcc" 1 3
# 37 "/usr/include/c++/4.8/bits/istream.tcc" 3
       
# 38 "/usr/include/c++/4.8/bits/istream.tcc" 3



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();
# 513 "/usr/include/c++/4.8/bits/istream.tcc" 3
       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>;




}
# 880 "/usr/include/c++/4.8/istream" 2 3
# 41 "/usr/include/c++/4.8/iostream" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 60 "/usr/include/c++/4.8/iostream" 3
  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;


}
# 83 "/usr/include/boost/assert.hpp" 2 3 4
# 1 "/usr/include/boost/current_function.hpp" 1 3 4
# 22 "/usr/include/boost/current_function.hpp" 3 4
namespace boost
{

namespace detail
{

inline void current_function_helper()
{
# 61 "/usr/include/boost/current_function.hpp" 3 4
}

}

}
# 84 "/usr/include/boost/assert.hpp" 2 3 4







    namespace boost
    {
      namespace assertion
      {
        namespace detail
        {
          inline void assertion_failed_msg(char const * expr, char const * msg, char const * function,
            char const * file, long line)
          {
            std::cerr
              << "***** Internal Program Error - assertion (" << expr << ") failed in "
              << function << ":\n"
              << file << '(' << line << "): " << msg << std::endl;
            std::abort();
          }
        }
      }
    }
# 30 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/checked_delete.hpp" 1 3 4
# 24 "/usr/include/boost/checked_delete.hpp" 3 4
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);
    }
};

}
# 31 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/throw_exception.hpp" 1 3 4



       
# 5 "/usr/include/boost/throw_exception.hpp" 3
# 29 "/usr/include/boost/throw_exception.hpp" 3
# 1 "/usr/include/boost/exception/detail/attribute_noreturn.hpp" 1 3 4
# 30 "/usr/include/boost/throw_exception.hpp" 2 3
# 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4
# 31 "/usr/include/boost/throw_exception.hpp" 2 3
# 43 "/usr/include/boost/throw_exception.hpp" 3
# 1 "/usr/include/boost/exception/exception.hpp" 1 3 4
# 9 "/usr/include/boost/exception/exception.hpp" 3 4
       
# 10 "/usr/include/boost/exception/exception.hpp" 3





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)
            {
            }
# 231 "/usr/include/boost/exception/exception.hpp" 3
        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
        {


#pragma GCC visibility push (default)


        template <class T>
        struct
        error_info_injector:
            public T,
            public exception
            {
            explicit
            error_info_injector( T const & x ):
                T(x)
                {
                }

            ~error_info_injector() throw()
                {
                }
            };


#pragma GCC visibility pop



        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
        {


#pragma GCC visibility push (default)


        class
        clone_base
            {
            public:

            virtual clone_base const * clone() const = 0;
            virtual void rethrow() const = 0;

            virtual
            ~clone_base() throw()
                {
                }
            };


#pragma GCC visibility pop



        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 virtual clone_base
            {
            struct clone_tag { };
            clone_impl( clone_impl const & x, clone_tag ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            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,clone_tag());
                }

            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);
        }
    }
# 44 "/usr/include/boost/throw_exception.hpp" 2 3






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(
                            enable_error_info(x),
                            throw_function(current_function)),
                        throw_file(file)),
                    throw_line(line)));
        }
    }

}
# 32 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 1 3 4
# 28 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3 4
# 26 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
namespace boost
{
# 39 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
class bad_weak_ptr: public std::exception
{
public:

    virtual char const * what() const throw()
    {
        return "tr1::bad_weak_ptr";
    }
};





}
# 29 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3 4
# 21 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_has_sync.hpp" 1 3 4
# 22 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 39 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 1 3 4
# 27 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 3 4
# 1 "/usr/include/boost/detail/sp_typeinfo.hpp" 1 3 4
# 109 "/usr/include/boost/detail/sp_typeinfo.hpp" 3 4
# 1 "/usr/include/c++/4.8/typeinfo" 1 3 4
# 32 "/usr/include/c++/4.8/typeinfo" 3 4
       
# 33 "/usr/include/c++/4.8/typeinfo" 3






#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 80 "/usr/include/c++/4.8/typeinfo" 3
namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const
    { return __name[0] == '*' ? __name + 1 : __name; }
# 115 "/usr/include/c++/4.8/typeinfo" 3
    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));
    }
# 136 "/usr/include/c++/4.8/typeinfo" 3
    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }
# 152 "/usr/include/c++/4.8/typeinfo" 3
    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
# 110 "/usr/include/boost/detail/sp_typeinfo.hpp" 2 3 4

namespace boost
{

namespace detail
{







typedef std::type_info sp_typeinfo;



}

}
# 28 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 2 3 4

namespace boost
{

namespace detail
{

inline int atomic_exchange_and_add( int * pw, int dv )
{




    int r;

    __asm__ __volatile__
    (
        "lock\n\t"
        "xadd %1, %0":
        "=m"( *pw ), "=r"( r ):
        "m"( *pw ), "1"( dv ):
        "memory", "cc"
    );

    return r;
}

inline void atomic_increment( int * pw )
{


    __asm__
    (
        "lock\n\t"
        "incl %0":
        "=m"( *pw ):
        "m"( *pw ):
        "cc"
    );
}

inline int atomic_conditional_increment( int * pw )
{




    int rv, tmp;

    __asm__
    (
        "movl %0, %%eax\n\t"
        "0:\n\t"
        "test %%eax, %%eax\n\t"
        "je 1f\n\t"
        "movl %%eax, %2\n\t"
        "incl %2\n\t"
        "lock\n\t"
        "cmpxchgl %2, %0\n\t"
        "jne 0b\n\t"
        "1:":
        "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ):
        "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;
    virtual void * get_untyped_deleter() = 0;

    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }

    bool add_ref_lock()
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }

    void release()
    {
        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
        {
            dispose();
            weak_release();
        }
    }

    void weak_add_ref()
    {
        atomic_increment( &weak_count_ );
    }

    void weak_release()
    {
        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
        {
            destroy();
        }
    }

    long use_count() const
    {
        return static_cast<int const volatile &>( use_count_ );
    }
};

}

}
# 40 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 30 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3 4
# 38 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 39 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2 3 4

namespace boost
{
# 50 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
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;
    }

    virtual void * get_untyped_deleter()
    {
        return 0;
    }
# 118 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
};
# 127 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
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;
    }

    virtual void * get_untyped_deleter()
    {
        return &reinterpret_cast<char&>( del );
    }
# 193 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
};

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;
    }

    virtual void * get_untyped_deleter()
    {
        return &reinterpret_cast<char&>( d_ );
    }
};





}

}
# 31 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4






# 1 "/usr/include/c++/4.8/functional" 1 3 4
# 46 "/usr/include/c++/4.8/functional" 3 4
       
# 47 "/usr/include/c++/4.8/functional" 3
# 38 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 47 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
namespace boost
{

namespace detail
{
# 60 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
struct sp_nothrow_tag {};

template< class D > struct sp_inplace_tag
{
};
# 98 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
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;
        }
# 149 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }




    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;
        }
# 186 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }



    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;
        }
# 218 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }



    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;
        }
# 266 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }



    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;
        }
# 314 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }







    template<class Y>
    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )



    {
# 337 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
        r.release();
    }
# 369 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    ~shared_count()
    {
        if( pi_ != 0 ) pi_->release();



    }

    shared_count(shared_count const & r): pi_(r.pi_)



    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }
# 397 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    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;
    }

    void * get_untyped_deleter() const
    {
        return pi_? pi_->get_untyped_deleter(): 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();
    }
# 509 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    ~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;
    }
}

}

}
# 33 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

# 1 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3 4
# 34 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 3 4
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) };
};

template< class Y, class T > struct sp_convertible< Y, T[] >
{
    enum _vt { value = false };
};

template< class Y, class T > struct sp_convertible< Y[], T[] >
{
    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};

template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
{
    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};

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 >
{
};

}

}
# 35 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 1 3 4
# 19 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 20 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 2 3 4
# 36 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4


# 1 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3 4
# 25 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 1 3 4
# 41 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/spinlock_sync.hpp" 1 3 4
# 18 "/usr/include/boost/smart_ptr/detail/spinlock_sync.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 1 3 4
# 91 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
namespace boost
{

namespace detail
{

inline void yield( unsigned k )
{
    if( k < 4 )
    {
    }

    else if( k < 16 )
    {
        __asm__ __volatile__( "rep; nop" : : : "memory" );
    }

    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 );
    }
}

}

}
# 19 "/usr/include/boost/smart_ptr/detail/spinlock_sync.hpp" 2 3 4





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();
        }
    };
};

}
}
# 42 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 2 3 4
# 26 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 27 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4

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}
};

}
}
# 39 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/memory_order.hpp" 1 3 4
# 21 "/usr/include/boost/memory_order.hpp" 3 4
namespace boost
{
# 41 "/usr/include/boost/memory_order.hpp" 3 4
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
};

}
# 40 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4


# 1 "/usr/include/c++/4.8/algorithm" 1 3 4
# 58 "/usr/include/c++/4.8/algorithm" 3 4
       
# 59 "/usr/include/c++/4.8/algorithm" 3



# 1 "/usr/include/c++/4.8/bits/stl_algo.h" 1 3
# 59 "/usr/include/c++/4.8/bits/stl_algo.h" 3
# 1 "/usr/include/c++/4.8/cstdlib" 1 3
# 39 "/usr/include/c++/4.8/cstdlib" 3
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 60 "/usr/include/c++/4.8/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/4.8/bits/algorithmfwd.h" 1 3
# 33 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
       
# 34 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
# 42 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 203 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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);
# 232 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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);
# 271 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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);
# 334 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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);
# 419 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  template<typename _BIter>
    bool
    next_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    bool
    next_permutation(_BIter, _BIter, _Compare);
# 436 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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);
# 457 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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);
# 540 "/usr/include/c++/4.8/bits/algorithmfwd.h" 3
  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 (&__a)[_Nm], _Tp (&__b)[_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);


}
# 61 "/usr/include/c++/4.8/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_heap.h" 1 3
# 61 "/usr/include/c++/4.8/bits/stl_heap.h" 3
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);
    }
# 154 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  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);
    }
# 204 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  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));
    }
# 279 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;
      ;

      if (__last - __first > 1)
 {
   --__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);
    }
# 357 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {

     

      ;
      ;
      ;

      if (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 384 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  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--;
 }
    }
# 424 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  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--;
 }
    }
# 463 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;
      ;

      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last);
 }
    }
# 492 "/usr/include/c++/4.8/bits/stl_heap.h" 3
  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);
 }
    }
# 589 "/usr/include/c++/4.8/bits/stl_heap.h" 3

}
# 62 "/usr/include/c++/4.8/bits/stl_algo.h" 2 3
# 71 "/usr/include/c++/4.8/bits/stl_algo.h" 3
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 _InputIterator, typename _Predicate>
    inline _InputIterator
    __find_if_not(_InputIterator __first, _InputIterator __last,
    _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && bool(__pred(*__first)))
 ++__first;
      return __first;
    }


  template<typename _RandomAccessIterator, typename _Predicate>
    _RandomAccessIterator
    __find_if_not(_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 (!bool(__pred(*__first)))
     return __first;
   ++__first;

   if (!bool(__pred(*__first)))
     return __first;
   ++__first;

   if (!bool(__pred(*__first)))
     return __first;
   ++__first;

   if (!bool(__pred(*__first)))
     return __first;
   ++__first;
 }

      switch (__last - __first)
 {
 case 3:
   if (!bool(__pred(*__first)))
     return __first;
   ++__first;
 case 2:
   if (!bool(__pred(*__first)))
     return __first;
   ++__first;
 case 1:
   if (!bool(__pred(*__first)))
     return __first;
   ++__first;
 case 0:
 default:
   return __last;
 }
    }


  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    __find_if_not(_InputIterator __first, _InputIterator __last,
    _Predicate __pred)
    {
      return std::__find_if_not(__first, __last, __pred,
    std::__iterator_category(__first));
    }




  template<typename _InputIterator, typename _Predicate, typename _Distance>
    _InputIterator
    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
    {
      for (; __len; --__len, ++__first)
 if (!bool(__pred(*__first)))
   break;
      return __first;
    }
# 345 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
 }
    }
# 430 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
 }
    }
# 669 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 716 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 895 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 932 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 1113 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 1156 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 1196 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 1236 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
 }
    }
# 1464 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1491 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
     }
 }
    }
# 1697 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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());
    }
# 1733 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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,
          _Predicate __pred, _Distance __len)
    {
      if (__len == 1)
 return __first;
      _ForwardIterator __middle = __first;
      std::advance(__middle, __len / 2);
      _ForwardIterator __left_split =
 std::__inplace_stable_partition(__first, __pred, __len / 2);


      _Distance __right_len = __len - __len / 2;
      _ForwardIterator __right_split =
 std::__find_if_not_n(__middle, __right_len, __pred);
      if (__right_len)
 __right_split = std::__inplace_stable_partition(__middle,
       __pred,
       __right_len);
      std::rotate(__left_split, __middle, __right_split);
      std::advance(__left_split, std::distance(__middle, __right_split));
      return __left_split;
    }







  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;



   *__result2 = (*__first);
   ++__result2;
   ++__first;
   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 __left_split =
     std::__stable_partition_adaptive(__first, __middle, __pred,
          __len / 2, __buffer,
          __buffer_size);


   _Distance __right_len = __len - __len / 2;
   _ForwardIterator __right_split =
     std::__find_if_not_n(__middle, __right_len, __pred);
   if (__right_len)
     __right_split =
       std::__stable_partition_adaptive(__right_split, __last, __pred,
            __right_len,
            __buffer, __buffer_size);
   std::rotate(__left_split, __middle, __right_split);
   std::advance(__left_split, std::distance(__middle, __right_split));
   return __left_split;
 }
    }
# 1912 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      __first = std::__find_if_not(__first, __last, __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, __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);
    }
# 1996 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 2062 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 2446 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 2493 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 2542 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 2595 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 2657 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 2718 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 2751 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 3175 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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()));
    }
# 3230 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 3570 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 3620 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 3675 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
     }
 }
    }
# 3732 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
     }
 }
    }
# 3788 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
     }
 }
    }
# 3845 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
     }
 }
    }
# 3905 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 3942 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4416 "/usr/include/c++/4.8/bits/stl_algo.h" 3



# 4432 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Function>
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {

     
      ;
      for (; __first != __last; ++__first)
 __f(*__first);
      return (__f);
    }
# 4453 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 4477 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 4507 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4547 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4579 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4611 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4643 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4668 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4710 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4781 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4856 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 4893 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 4935 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 4972 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 5005 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 5037 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 5069 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 5100 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 5137 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5176 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5208 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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)));
    }
# 5236 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5272 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    inline _ForwardIterator
    partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      return std::__partition(__first, __last, __pred,
         std::__iterator_category(__first));
    }
# 5306 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 5345 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 5382 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 5421 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 5459 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
 }
    }
# 5495 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
 }
    }
# 5537 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5601 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5661 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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()));
    }
# 5703 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 5749 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5816 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 5883 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 5940 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 5998 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 6059 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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);
    }
# 6117 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 6183 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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));
    }
# 6240 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 6268 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 6296 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }
# 6324 "/usr/include/c++/4.8/bits/stl_algo.h" 3
  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;
    }


}
# 63 "/usr/include/c++/4.8/algorithm" 2 3
# 43 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4


# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 46 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 55 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
namespace boost
{

template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
class enable_shared_from_raw;

namespace detail
{



template< class T > struct sp_element
{
    typedef T type;
};



template< class T > struct sp_element< T[] >
{
    typedef T type;
};



template< class T, std::size_t N > struct sp_element< T[N] >
{
    typedef T type;
};







template< class T > struct sp_dereference
{
    typedef T & type;
};

template<> struct sp_dereference< void >
{
    typedef void type;
};



template<> struct sp_dereference< void const >
{
    typedef void type;
};

template<> struct sp_dereference< void volatile >
{
    typedef void type;
};

template<> struct sp_dereference< void const volatile >
{
    typedef void type;
};





template< class T > struct sp_dereference< T[] >
{
    typedef void type;
};



template< class T, std::size_t N > struct sp_dereference< T[N] >
{
    typedef void type;
};







template< class T > struct sp_member_access
{
    typedef T * type;
};



template< class T > struct sp_member_access< T[] >
{
    typedef void type;
};



template< class T, std::size_t N > struct sp_member_access< T[N] >
{
    typedef void type;
};







template< class T > struct sp_array_access
{
    typedef void type;
};



template< class T > struct sp_array_access< T[] >
{
    typedef T & type;
};



template< class T, std::size_t N > struct sp_array_access< T[N] >
{
    typedef T & type;
};







template< class T > struct sp_extent
{
    enum _vt { value = 0 };
};



template< class T, std::size_t N > struct sp_extent< T[N] >
{
    enum _vt { value = N };
};





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 > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
# 233 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
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 Y, class T > inline void sp_assert_convertible()
{



    typedef char tmp[ sp_convertible< Y, T >::value? 1: -1 ];
    (void)sizeof( tmp );







}



template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
{
    boost::detail::shared_count( p ).swap( pn );
    boost::detail::sp_enable_shared_from_this( ppx, p, p );
}



template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
{
    sp_assert_convertible< Y[], T[] >();
    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
}

template< class T, std::size_t N, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
{
    sp_assert_convertible< Y[N], T[N] >();
    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
}





template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
{
    boost::detail::sp_enable_shared_from_this( ppx, p, p );
}



template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
{
    sp_assert_convertible< Y[], T[] >();
}

template< class T, std::size_t N, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
{
    sp_assert_convertible< Y[N], T[N] >();
}



}
# 328 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class T> class shared_ptr
{
private:


    typedef shared_ptr<T> this_type;

public:

    typedef typename boost::detail::sp_element< T >::type element_type;

    shared_ptr() : px( 0 ), pn()
    {
    }
# 351 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn()
    {
        boost::detail::sp_pointer_construct( this, p, pn );
    }







    template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, d )
    {
        boost::detail::sp_deleter_construct( this, p );
    }
# 378 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_deleter_construct( this, p );
    }
# 403 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y>
    explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
    {
        boost::detail::sp_assert_convertible< Y, T >();


        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 )
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }


    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, element_type * p ) : px( p ), pn( r.pn )
    {
    }



    template<class Y>
    explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        Y * tmp = r.get();
        pn = boost::detail::shared_count( r );

        boost::detail::sp_deleter_construct( this, tmp );
    }
# 471 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
    {
        typedef typename Ap::element_type Y;

        boost::detail::sp_assert_convertible< Y, T >();

        Y * tmp = r.get();
        pn = boost::detail::shared_count( r );

        boost::detail::sp_deleter_construct( this, tmp );
    }
# 505 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    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;
    }
# 542 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    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;
    }
# 617 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    void reset()
    {
        this_type().swap(*this);
    }

    template<class Y> void reset( Y * p )
    {
        ((p == 0 || p != px) ? static_cast<void> (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 624, __PRETTY_FUNCTION__));
        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, element_type * p )
    {
        this_type( r, p ).swap( *this );
    }


    typename boost::detail::sp_dereference< T >::type operator* () const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 646, __PRETTY_FUNCTION__));
        return *px;
    }


    typename boost::detail::sp_member_access< T >::type operator-> () const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 653, __PRETTY_FUNCTION__));
        return px;
    }


    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 660, __PRETTY_FUNCTION__));
        ((i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )) ? static_cast<void> (0) : __assert_fail ("i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 661, __PRETTY_FUNCTION__));

        return px[ i ];
    }

    element_type * get() const
    {
        return px;
    }


# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
# 50 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    typedef element_type * this_type::*unspecified_bool_type;

    operator unspecified_bool_type() const
    {
        return px == 0? 0: &this_type::px;
    }




    bool operator! () const
    {
        return px == 0;
    }
# 673 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

    bool unique() const
    {
        return pn.unique();
    }

    long use_count() const
    {
        return pn.use_count();
    }

    void swap( shared_ptr & 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 );
    }

    void * _internal_get_untyped_deleter() const
    {
        return pn.get_untyped_deleter();
    }

    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;




    element_type * 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();
}
# 778 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
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 )
{
    (void) static_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = static_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}

template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r )
{
    (void) const_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = const_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r )
{
    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = dynamic_cast< E* >( r.get() );
    return p? shared_ptr<T>( r, p ): shared_ptr<T>();
}

template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r )
{
    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = reinterpret_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}



template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p)
{
    return p.get();
}
# 857 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
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;
}
# 872 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
namespace detail
{
# 890 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p )
{
    return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
}



class esft2_deleter_wrapper
{
private:

    shared_ptr<void> deleter_;

public:

    esft2_deleter_wrapper()
    {
    }

    template< class T > void set_deleter( shared_ptr<T> const & deleter )
    {
        deleter_ = deleter;
    }

    template<typename D> D* get_deleter() const
    {
        return boost::detail::basic_get_deleter<D>( deleter_ );
    }

    template< class T> void operator()( T* )
    {
        ((deleter_.use_count() <= 1) ? static_cast<void> (0) : __assert_fail ("deleter_.use_count() <= 1", "/usr/include/boost/smart_ptr/shared_ptr.hpp", 921, __PRETTY_FUNCTION__));
        deleter_.reset();
    }
};

}

template<class D, class T> D * get_deleter( shared_ptr<T> const & p )
{
    D *del = boost::detail::basic_get_deleter<D>(p);

    if(del == 0)
    {
        boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);


        if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
    }

    return del;
}





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() );
}

}
# 18 "/usr/include/boost/shared_ptr.hpp" 2 3 4
# 21 "./drizzled/common_fwd.h" 2
# 1 "/usr/include/boost/thread/condition_variable.hpp" 1 3 4
# 12 "/usr/include/boost/thread/condition_variable.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/platform.hpp" 1 3 4
# 17 "/usr/include/boost/thread/detail/platform.hpp" 3 4
# 1 "/usr/include/boost/config/requires_threads.hpp" 1 3 4
# 18 "/usr/include/boost/thread/detail/platform.hpp" 2 3 4
# 13 "/usr/include/boost/thread/condition_variable.hpp" 2 3 4



# 1 "/usr/include/boost/thread/pthread/condition_variable.hpp" 1 3 4
# 9 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
# 1 "/usr/include/boost/thread/pthread/timespec.hpp" 1 3 4
# 10 "/usr/include/boost/thread/pthread/timespec.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/config.hpp" 1 3 4
# 381 "/usr/include/boost/thread/detail/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 382 "/usr/include/boost/thread/detail/config.hpp" 2 3 4
# 11 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4
# 1 "/usr/include/boost/thread/thread_time.hpp" 1 3 4
# 9 "/usr/include/boost/thread/thread_time.hpp" 3 4
# 1 "/usr/include/boost/date_time/time_clock.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/time_clock.hpp" 3 4
# 1 "/usr/include/boost/date_time/c_time.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/c_time.hpp" 3 4
# 1 "/usr/include/c++/4.8/ctime" 1 3 4
# 39 "/usr/include/c++/4.8/ctime" 3 4
       
# 40 "/usr/include/c++/4.8/ctime" 3
# 58 "/usr/include/c++/4.8/ctime" 3
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;
}
# 18 "/usr/include/boost/date_time/c_time.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/stdexcept" 1 3 4
# 36 "/usr/include/c++/4.8/stdexcept" 3 4
       
# 37 "/usr/include/c++/4.8/stdexcept" 3




namespace std __attribute__ ((__visibility__ ("default")))
{

# 55 "/usr/include/c++/4.8/stdexcept" 3
  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();
  };




}
# 20 "/usr/include/boost/date_time/c_time.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/compiler_config.hpp" 1 3 4
# 11 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 12 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
# 31 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/include/boost/date_time/locale_config.hpp" 1 3 4
# 32 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
# 54 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 100 "/usr/include/boost/cstdint.hpp" 3 4
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;

}
# 55 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
# 157 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 158 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
# 22 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
# 31 "/usr/include/boost/date_time/c_time.hpp" 3 4
# 1 "/usr/include/i386-linux-gnu/sys/time.h" 1 3 4
# 28 "/usr/include/i386-linux-gnu/sys/time.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/time.h" 1 3 4
# 29 "/usr/include/i386-linux-gnu/sys/time.h" 2 3 4
# 38 "/usr/include/i386-linux-gnu/sys/time.h" 3 4
extern "C" {
# 56 "/usr/include/i386-linux-gnu/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };

typedef struct timezone *__restrict __timezone_ptr_t;
# 72 "/usr/include/i386-linux-gnu/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
    __timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));




extern int settimeofday (const struct timeval *__tv,
    const struct timezone *__tz)
     throw ();





extern int adjtime (const struct timeval *__delta,
      struct timeval *__olddelta) throw ();




enum __itimer_which
  {

    ITIMER_REAL = 0,


    ITIMER_VIRTUAL = 1,



    ITIMER_PROF = 2

  };



struct itimerval
  {

    struct timeval it_interval;

    struct timeval it_value;
  };






typedef int __itimer_which_t;




extern int getitimer (__itimer_which_t __which,
        struct itimerval *__value) throw ();




extern int setitimer (__itimer_which_t __which,
        const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) throw ();




extern int utimes (const char *__file, const struct timeval __tvp[2])
     throw () __attribute__ ((__nonnull__ (1)));



extern int lutimes (const char *__file, const struct timeval __tvp[2])
     throw () __attribute__ ((__nonnull__ (1)));


extern int futimes (int __fd, const struct timeval __tvp[2]) throw ();






extern int futimesat (int __fd, const char *__file,
        const struct timeval __tvp[2]) throw ();
# 190 "/usr/include/i386-linux-gnu/sys/time.h" 3 4
}
# 32 "/usr/include/boost/date_time/c_time.hpp" 2 3 4






namespace boost {
namespace date_time {
# 52 "/usr/include/boost/date_time/c_time.hpp" 3 4
  struct c_time {
    public:


      inline
      static std::tm* localtime(const std::time_t* t, std::tm* result)
      {
# 67 "/usr/include/boost/date_time/c_time.hpp" 3 4
        result = localtime_r(t, result);

        if (!result)
          boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
        return result;
      }

      inline
      static std::tm* gmtime(const std::time_t* t, std::tm* result)
      {
# 85 "/usr/include/boost/date_time/c_time.hpp" 3 4
        result = gmtime_r(t, result);

        if (!result)
          boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
        return result;
      }
# 120 "/usr/include/boost/date_time/c_time.hpp" 3 4
  };
}}
# 17 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4


namespace boost {
namespace date_time {





  template<class time_type>
  class second_clock
  {
  public:
    typedef typename time_type::date_type date_type;
    typedef typename time_type::time_duration_type time_duration_type;

    static time_type local_time()
    {
      ::std::time_t t;
      ::std::time(&t);
      ::std::tm curr, *curr_ptr;

      curr_ptr = c_time::localtime(&t, &curr);
      return create_time(curr_ptr);
    }



    static time_type universal_time()
    {

      ::std::time_t t;
      ::std::time(&t);
      ::std::tm curr, *curr_ptr;

      curr_ptr = c_time::gmtime(&t, &curr);
      return create_time(curr_ptr);
    }

    template<class time_zone_type>
    static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
    {
      typedef typename time_type::utc_time_type utc_time_type;
      utc_time_type utc_time = second_clock<utc_time_type>::universal_time();
      return time_type(utc_time, tz_ptr);
    }


  private:
    static time_type create_time(::std::tm* current)
    {
      date_type d(static_cast<unsigned short>(current->tm_year + 1900),
                  static_cast<unsigned short>(current->tm_mon + 1),
                  static_cast<unsigned short>(current->tm_mday));
      time_duration_type td(current->tm_hour,
                            current->tm_min,
                            current->tm_sec);
      return time_type(d,td);
    }

  };


} }
# 10 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/microsec_time_clock.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/microsec_time_clock.hpp" 2 3 4





# 1 "/usr/include/boost/date_time/filetime_functions.hpp" 1 3 4
# 24 "/usr/include/boost/date_time/microsec_time_clock.hpp" 2 3 4



namespace boost {
namespace date_time {
# 38 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
  template<class time_type>
  class microsec_clock
  {
  private:

    typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);

  public:
    typedef typename time_type::date_type date_type;
    typedef typename time_type::time_duration_type time_duration_type;
    typedef typename time_duration_type::rep_type resolution_traits_type;



    template<class time_zone_type>
    static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
    {
      typedef typename time_type::utc_time_type utc_time_type;
      typedef second_clock<utc_time_type> second_clock;


      utc_time_type utc_time = second_clock::universal_time();
      time_duration_type utc_offset = second_clock::local_time() - utc_time;


      utc_time = microsec_clock<utc_time_type>::local_time() - utc_offset;
      return time_type(utc_time, tz_ptr);
    }


    static time_type local_time()
    {
      return create_time(&c_time::localtime);
    }


    static time_type universal_time()
    {
      return create_time(&c_time::gmtime);
    }

  private:
    static time_type create_time(time_converter converter)
    {

      timeval tv;
      gettimeofday(&tv, 0);
      std::time_t t = tv.tv_sec;
      boost::uint32_t sub_sec = tv.tv_usec;
# 99 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
      std::tm curr;
      std::tm* curr_ptr = converter(&t, &curr);
      date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
                  static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
                  static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));





      int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);

      time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
                            static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
                            static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
                            sub_sec * adjust);

      return time_type(d,td);
    }
  };


} }
# 11 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/ptime.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/ptime.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 13 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/limits.hpp" 1 3 4
# 19 "/usr/include/boost/limits.hpp" 3 4
# 1 "/usr/include/c++/4.8/limits" 1 3 4
# 40 "/usr/include/c++/4.8/limits" 3 4
       
# 41 "/usr/include/c++/4.8/limits" 3
# 147 "/usr/include/c++/4.8/limits" 3
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
  };
# 191 "/usr/include/c++/4.8/limits" 3
  struct __numeric_limits_base
  {


    static const bool is_specialized = false;




    static const int digits = 0;


    static const int digits10 = 0;
# 212 "/usr/include/c++/4.8/limits" 3
    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;
# 277 "/usr/include/c++/4.8/limits" 3
    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;
  };
# 303 "/usr/include/c++/4.8/limits" 3
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {


      static _Tp
      min() throw() { return _Tp(); }


      static _Tp
      max() throw() { return _Tp(); }
# 324 "/usr/include/c++/4.8/limits" 3
      static _Tp
      epsilon() throw() { return _Tp(); }


      static _Tp
      round_error() throw() { return _Tp(); }


      static _Tp
      infinity() throw() { return _Tp(); }



      static _Tp
      quiet_NaN() throw() { return _Tp(); }



      static _Tp
      signaling_NaN() throw() { return _Tp(); }




      static _Tp
      denorm_min() throw() { return _Tp(); }
    };
# 370 "/usr/include/c++/4.8/limits" 3
  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 = true;
      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) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (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 = !is_signed;

      static const bool traps = true;
      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 = false;

      static const bool traps = true;
      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 = true;
      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) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (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 = !is_signed;

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style
       = round_toward_zero;
    };
# 841 "/usr/include/c++/4.8/limits" 3
  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 = false;

      static const bool traps = true;
      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 = true;
      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 = false;

      static const bool traps = true;
      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 = true;
      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 -2147483647L - 1; }

      static long
      max() throw() { return 2147483647L; }






      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 = false;

      static const bool traps = true;
      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 2147483647L * 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 = true;
      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 = false;

      static const bool traps = true;
      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 = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style
       = round_toward_zero;
    };
# 1552 "/usr/include/c++/4.8/limits" 3
  template<>
    struct numeric_limits<float>
    {
      static const bool is_specialized = true;

      static float
      min() throw() { return 1.17549435082228750797e-38F; }

      static float
      max() throw() { return 3.40282346638528859812e+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.19209289550781250000e-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.40129846432481707092e-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.22507385850720138309e-308L); }

      static double
      max() throw() { return double(1.79769313486231570815e+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.22044604925031308085e-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.94065645841246544177e-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 3.36210314311209350626e-4932L; }

      static long double
      max() throw() { return 1.18973149535723176502e+4932L; }






      static const int digits = 64;
      static const int digits10 = 18;




      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 1.08420217248550443401e-19L; }

      static long double
      round_error() throw() { return 0.5L; }

      static const int min_exponent = (-16381);
      static const int min_exponent10 = (-4931);
      static const int max_exponent = 16384;
      static const int max_exponent10 = 4932;

      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 3.64519953188247460253e-4951L; }

      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;
    };






}
# 20 "/usr/include/boost/limits.hpp" 2 3 4
# 14 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/config/no_tr1/cmath.hpp" 1 3 4
# 21 "/usr/include/boost/config/no_tr1/cmath.hpp" 3 4
# 1 "/usr/include/c++/4.8/cmath" 1 3 4
# 39 "/usr/include/c++/4.8/cmath" 3 4
       
# 40 "/usr/include/c++/4.8/cmath" 3




# 1 "/usr/include/math.h" 1 3 4
# 29 "/usr/include/math.h" 3 4
extern "C" {



# 1 "/usr/include/i386-linux-gnu/bits/huge_val.h" 1 3 4
# 34 "/usr/include/math.h" 2 3 4

# 1 "/usr/include/i386-linux-gnu/bits/huge_valf.h" 1 3 4
# 36 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/bits/huge_vall.h" 1 3 4
# 37 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/inf.h" 1 3 4
# 40 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/nan.h" 1 3 4
# 43 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/i386-linux-gnu/bits/mathdef.h" 1 3 4
# 35 "/usr/include/i386-linux-gnu/bits/mathdef.h" 3 4
typedef long double float_t;

typedef long double double_t;
# 47 "/usr/include/math.h" 2 3 4
# 70 "/usr/include/math.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/i386-linux-gnu/bits/mathcalls.h" 3 4


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 () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));


extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));



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 ();
# 71 "/usr/include/math.h" 2 3 4
# 89 "/usr/include/math.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/i386-linux-gnu/bits/mathcalls.h" 3 4


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 () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));


extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));



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 ();
# 90 "/usr/include/math.h" 2 3 4
# 136 "/usr/include/math.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/i386-linux-gnu/bits/mathcalls.h" 3 4


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 () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));


extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));



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 ();
# 137 "/usr/include/math.h" 2 3 4
# 152 "/usr/include/math.h" 3 4
extern int signgam;
# 193 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

      4
  };
# 291 "/usr/include/math.h" 3 4
typedef enum
{
  _IEEE_ = -1,
  _SVID_,
  _XOPEN_,
  _POSIX_,
  _ISOC_
} _LIB_VERSION_TYPE;




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 314 "/usr/include/math.h" 3 4
struct __exception



  {
    int type;
    char *name;
    double arg1;
    double arg2;
    double retval;
  };


extern int matherr (struct __exception *__exc) throw ();
# 416 "/usr/include/math.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/mathinline.h" 1 3 4
# 123 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4



extern __inline __attribute__ ((__always_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__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) __signbit (double __x) throw ()
{





  __extension__ union { double __d; int __i[2]; } __u = { __d: __x };
  return __u.__i[1] < 0;

}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) __signbitl (long double __x) throw ()
{
  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
  return (__u.__i[2] & 0x8000) != 0;
}


# 644 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __attribute__ ((__leaf__)) __atan2l (long double __y, long double __x) throw () { return __builtin_atan2l (__y, __x); }
# 684 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) double __attribute__ ((__leaf__)) fabs (double __x) throw () { return __builtin_fabs (__x); }

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) float __attribute__ ((__leaf__)) fabsf (float __x) throw () { return __builtin_fabsf (__x); }
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __attribute__ ((__leaf__)) fabsl (long double __x) throw () { return __builtin_fabsl (__x); }

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __attribute__ ((__leaf__)) __fabsl (long double __x) throw () { return __builtin_fabsl (__x); }
# 717 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __sgn1l (long double) throw (); extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __attribute__ ((__leaf__)) __sgn1l (long double __x) throw () { __extension__ union { long double __xld; unsigned int __xi[3]; } __n = { __xld: __x }; __n.__xi[2] = (__n.__xi[2] & 0x8000) | 0x3fff; __n.__xi[1] = 0x80000000; __n.__xi[0] = 0; return __n.__xld; }
# 741 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) double __attribute__ ((__leaf__)) floor (double __x) throw () { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0400, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) float __attribute__ ((__leaf__)) floorf (float __x) throw () { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0400, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __attribute__ ((__leaf__)) floorl (long double __x) throw () { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0400, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; }
# 759 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) double __attribute__ ((__leaf__)) ceil (double __x) throw () { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0800, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) float __attribute__ ((__leaf__)) ceilf (float __x) throw () { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0800, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; } extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long double __attribute__ ((__leaf__)) ceill (long double __x) throw () { register long double __value; register int __ignore; unsigned short int __cw; unsigned short int __cwtmp; __asm __volatile ("fnstcw %3\n\t" "movzwl %3, %1\n\t" "andl $0xf3ff, %1\n\t" "orl $0x0800, %1\n\t" "movw %w1, %2\n\t" "fldcw %2\n\t" "frndint\n\t" "fldcw %3" : "=t" (__value), "=&q" (__ignore), "=m" (__cwtmp), "=m" (__cw) : "0" (__x)); return __value; }
# 876 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) lrintf (float __x) throw ()
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) lrint (double __x) throw ()
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long int
__attribute__ ((__leaf__)) lrintl (long double __x) throw ()
{
  long int __lrintres; __asm__ __volatile__ ("fistpl %0" : "=m" (__lrintres) : "t" (__x) : "st"); return __lrintres;
}
# 899 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) llrintf (float __x) throw ()
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) llrint (double __x) throw ()
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) long long int
__attribute__ ((__leaf__)) llrintl (long double __x) throw ()
{
  long long int __llrintres; __asm__ __volatile__ ("fistpll %0" : "=m" (__llrintres) : "t" (__x) : "st"); return __llrintres;
}
# 936 "/usr/include/i386-linux-gnu/bits/mathinline.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) __finite (double __x) throw ()
{
  return (__extension__
   (((((union { double __d; int __i[2]; }) {__d: __x}).__i[1]
      | 0x800fffffu) + 1) >> 31));
}
# 417 "/usr/include/math.h" 2 3 4
# 478 "/usr/include/math.h" 3 4
}
# 45 "/usr/include/c++/4.8/cmath" 2 3
# 75 "/usr/include/c++/4.8/cmath" 3
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); }


  template<typename _Tp, typename _Up>
    inline
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmod(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmod(__type(__x), __type(__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); }


}
# 555 "/usr/include/c++/4.8/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 805 "/usr/include/c++/4.8/cmath" 3
  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(0, 1, 4,
      3, 2, __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));
    }




}
# 22 "/usr/include/boost/config/no_tr1/cmath.hpp" 2 3 4
# 16 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_duration.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/time_duration.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/usr/include/boost/operators.hpp" 1 3 4
# 86 "/usr/include/boost/operators.hpp" 3 4
# 1 "/usr/include/boost/iterator.hpp" 1 3 4
# 17 "/usr/include/boost/iterator.hpp" 3 4
# 1 "/usr/include/c++/4.8/iterator" 1 3 4
# 58 "/usr/include/c++/4.8/iterator" 3 4
       
# 59 "/usr/include/c++/4.8/iterator" 3







# 1 "/usr/include/c++/4.8/bits/stream_iterator.h" 1 3
# 33 "/usr/include/c++/4.8/bits/stream_iterator.h" 3
       
# 34 "/usr/include/c++/4.8/bits/stream_iterator.h" 3



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); }
# 152 "/usr/include/c++/4.8/bits/stream_iterator.h" 3
  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) {}
# 183 "/usr/include/c++/4.8/bits/stream_iterator.h" 3
      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; }
    };




}
# 67 "/usr/include/c++/4.8/iterator" 2 3
# 18 "/usr/include/boost/iterator.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 19 "/usr/include/boost/iterator.hpp" 2 3 4


namespace boost
{
# 39 "/usr/include/boost/iterator.hpp" 3 4
  namespace detail {
   template <class Category, class T, class Distance, class Pointer, class Reference>

   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
# 51 "/usr/include/boost/iterator.hpp" 3 4
  }

  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> {};

}
# 87 "/usr/include/boost/operators.hpp" 2 3 4
# 97 "/usr/include/boost/operators.hpp" 3 4
namespace boost {
namespace detail {

template <typename T> class empty_base {






};

}
}
# 120 "/usr/include/boost/operators.hpp" 3 4
namespace boost
{







template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable2 : B
{
     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
     friend bool operator>(const U& x, const T& y) { return y < x; }
     friend bool operator<(const U& x, const T& y) { return y > x; }
     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct less_than_comparable1 : B
{
     friend bool operator>(const T& x, const T& y) { return y < x; }
     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equality_comparable2 : B
{
     friend bool operator==(const U& y, const T& x) { return x == y; }
     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct equality_comparable1 : B
{
     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
};
# 256 "/usr/include/boost/operators.hpp" 3 4
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };







template <class T, class B = ::boost::detail::empty_base<T> >
struct incrementable : B
{
  friend T operator++(T& x, int)
  {
    incrementable_type nrv(x);
    ++x;
    return nrv;
  }
private:
  typedef T incrementable_type;
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct decrementable : B
{
  friend T operator--(T& x, int)
  {
    decrementable_type nrv(x);
    --x;
    return nrv;
  }
private:
  typedef T decrementable_type;
};



template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct dereferenceable : B
{
  P operator->() const
  {
    return &*static_cast<const T&>(*this);
  }
};

template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
struct indexable : B
{
  R operator[](I n) const
  {
    return *(static_cast<const T&>(*this) + n);
  }
};
# 354 "/usr/include/boost/operators.hpp" 3 4
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };



template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct equivalent2 : B
{
  friend bool operator==(const T& x, const U& y)
  {
    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
  }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct equivalent1 : B
{
  friend bool operator==(const T&x, const T&y)
  {
    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
  }
};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct partially_ordered2 : B
{
  friend bool operator<=(const T& x, const U& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const U& y)
    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
  friend bool operator>(const U& x, const T& y)
    { return y < x; }
  friend bool operator<(const U& x, const T& y)
    { return y > x; }
  friend bool operator<=(const U& x, const T& y)
    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
  friend bool operator>=(const U& x, const T& y)
    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
};

template <class T, class B = ::boost::detail::empty_base<T> >
struct partially_ordered1 : B
{
  friend bool operator>(const T& x, const T& y)
    { return y < x; }
  friend bool operator<=(const T& x, const T& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend bool operator>=(const T& x, const T& y)
    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
};



template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct totally_ordered2
    : less_than_comparable2<T, U
    , equality_comparable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct totally_ordered1
    : less_than_comparable1<T
    , equality_comparable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct additive2
    : addable2<T, U
    , subtractable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct additive1
    : addable1<T
    , subtractable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct multiplicative2
    : multipliable2<T, U
    , dividable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct multiplicative1
    : multipliable1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative2
    : multiplicative2<T, U
    , modable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_multiplicative1
    : multiplicative1<T
    , modable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct arithmetic2
    : additive2<T, U
    , multiplicative2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct arithmetic1
    : additive1<T
    , multiplicative1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic2
    : additive2<T, U
    , integer_multiplicative2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct integer_arithmetic1
    : additive1<T
    , integer_multiplicative1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct bitwise2
    : xorable2<T, U
    , andable2<T, U
    , orable2<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct bitwise1
    : xorable1<T
    , andable1<T
    , orable1<T, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct unit_steppable
    : incrementable<T
    , decrementable<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct shiftable2
    : left_shiftable2<T, U
    , right_shiftable2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct shiftable1
    : left_shiftable1<T
    , right_shiftable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ring_operators2
    : additive2<T, U
    , subtractable2_left<T, U
    , multipliable2<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ring_operators1
    : additive1<T
    , multipliable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators2
    : ring_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_ring_operators1
    : ring_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct field_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct field_operators1
    : ring_operators1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators2
    : field_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_field_operators1
    : field_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct euclidean_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators2
    : totally_ordered2<T, U
    , euclidean_ring_operators2<T, U, B
      > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct ordered_euclidean_ring_operators1
    : totally_ordered1<T
    , euclidean_ring_operators1<T, B
      > > {};

template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};

template <class T, class B = ::boost::detail::empty_base<T> >
struct output_iteratable
    : incrementable<T, B
      > {};

template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct forward_iteratable
    : input_iteratable<T, P, B
      > {};

template <class T, class P, class B = ::boost::detail::empty_base<T> >
struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
      > > {};





template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
    , additive2<T, D
    , indexable<T, D, R, B
      > > > > {};


}
# 720 "/usr/include/boost/operators.hpp" 3 4
namespace boost {


namespace detail {
  struct true_t {};
  struct false_t {};
}




template<class T> struct is_chained_base {
  typedef ::boost::detail::false_t value;
};

}
# 831 "/usr/include/boost/operators.hpp" 3 4
namespace boost {

template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };

 template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };

 template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };

template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };

template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
 template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
# 893 "/usr/include/boost/operators.hpp" 3 4
template <class T, class U>
struct operators2
    : totally_ordered2<T,U
    , integer_arithmetic2<T,U
    , bitwise2<T,U
      > > > {};


template <class T, class U = T>
struct operators : operators2<T, U> {};

template <class T> struct operators<T, T>



    : totally_ordered<T
    , integer_arithmetic<T
    , bitwise<T
    , unit_steppable<T
      > > > > {};




template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V const *,
          class R = V const &>
struct input_iterator_helper
  : input_iteratable<T, P
  , boost::iterator<std::input_iterator_tag, V, D, P, R
    > > {};

template<class T>
struct output_iterator_helper
  : output_iteratable<T
  , boost::iterator<std::output_iterator_tag, void, void, void, void
  > >
{
  T& operator*() { return static_cast<T&>(*this); }
  T& operator++() { return static_cast<T&>(*this); }
};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct forward_iterator_helper
  : forward_iteratable<T, P
  , boost::iterator<std::forward_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct bidirectional_iterator_helper
  : bidirectional_iteratable<T, P
  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct random_access_iterator_helper
  : random_access_iteratable<T, P, D, R
  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
    > >
{
  friend D requires_difference_operator(const T& x, const T& y) {
    return x - y;
  }
};

}
# 14 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/usr/include/boost/static_assert.hpp" 1 3 4
# 51 "/usr/include/boost/static_assert.hpp" 3 4
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{};

}
# 15 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_defs.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/time_defs.hpp" 3 4
namespace boost {
namespace date_time {


  enum time_resolutions {
    sec,
    tenth,
    hundreth,
    hundredth = hundreth,
    milli,
    ten_thousandth,
    micro,
    nano,
    NumResolutions
  };


  enum dst_flags {not_dst, is_dst, calculate};


} }
# 16 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/special_defs.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/special_defs.hpp" 3 4
namespace boost {
namespace date_time {

    enum special_values {not_a_date_time,
                         neg_infin, pos_infin,
                         min_date_time, max_date_time,
                         not_special, NumSpecialValues};


} }
# 17 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4


namespace boost {
namespace date_time {
# 33 "/usr/include/boost/date_time/time_duration.hpp" 3 4
  template<class T, typename rep_type>
  class time_duration : private
      boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >





  {
  public:
    typedef T duration_type;
    typedef rep_type traits_type;
    typedef typename rep_type::day_type day_type;
    typedef typename rep_type::hour_type hour_type;
    typedef typename rep_type::min_type min_type;
    typedef typename rep_type::sec_type sec_type;
    typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
    typedef typename rep_type::tick_type tick_type;
    typedef typename rep_type::impl_type impl_type;

    time_duration() : ticks_(0) {}
    time_duration(hour_type hours_in,
                  min_type minutes_in,
                  sec_type seconds_in=0,
                  fractional_seconds_type frac_sec_in = 0) :
      ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
    {}


    time_duration(const time_duration<T, rep_type>& other)
      : ticks_(other.ticks_)
    {}

    time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
    {}

    static duration_type unit()
    {
      return duration_type(0,0,0,1);
    }

    static tick_type ticks_per_second()
    {
      return rep_type::res_adjust();
    }

    static time_resolutions resolution()
    {
      return rep_type::resolution();
    }

    hour_type hours() const
    {
      return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
    }

    min_type minutes() const
    {
      return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
    }

    sec_type seconds() const
    {
      return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
    }

    sec_type total_seconds() const
    {
      return static_cast<sec_type>(ticks() / ticks_per_second());
    }

    tick_type total_milliseconds() const
    {
      if (ticks_per_second() < 1000) {
        return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
      }
      return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
    }

    tick_type total_nanoseconds() const
    {
      if (ticks_per_second() < 1000000000) {
        return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
      }
      return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
    }

    tick_type total_microseconds() const
    {
      if (ticks_per_second() < 1000000) {
        return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
      }
      return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
    }

    fractional_seconds_type fractional_seconds() const
    {
      return (ticks() % ticks_per_second());
    }

    static unsigned short num_fractional_digits()
    {
      return rep_type::num_fractional_digits();
    }
    duration_type invert_sign() const
    {
      return duration_type(ticks_ * (-1));
    }
    bool is_negative() const
    {
      return ticks_ < 0;
    }
    bool operator<(const time_duration& rhs) const
    {
      return ticks_ < rhs.ticks_;
    }
    bool operator==(const time_duration& rhs) const
    {
      return ticks_ == rhs.ticks_;
    }

    duration_type operator-()const
    {
      return duration_type(ticks_ * (-1));
    }
    duration_type operator-(const duration_type& d) const
    {
      return duration_type(ticks_ - d.ticks_);
    }
    duration_type operator+(const duration_type& d) const
    {
      return duration_type(ticks_ + d.ticks_);
    }
    duration_type operator/(int divisor) const
    {
      return duration_type(ticks_ / divisor);
    }
    duration_type operator-=(const duration_type& d)
    {
      ticks_ = ticks_ - d.ticks_;
      return duration_type(ticks_);
    }
    duration_type operator+=(const duration_type& d)
    {
      ticks_ = ticks_ + d.ticks_;
      return duration_type(ticks_);
    }

    duration_type operator/=(int divisor)
    {
      ticks_ = ticks_ / divisor;
      return duration_type(ticks_);
    }

    duration_type operator*(int rhs) const
    {
      return duration_type(ticks_ * rhs);
    }
    duration_type operator*=(int divisor)
    {
      ticks_ = ticks_ * divisor;
      return duration_type(ticks_);
    }
    tick_type ticks() const
    {
      return traits_type::as_number(ticks_);
    }


    bool is_special()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_special();
      }
      else{
        return false;
      }
    }

    bool is_pos_infinity()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_pos_infinity();
      }
      else{
        return false;
      }
    }

    bool is_neg_infinity()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_neg_infinity();
      }
      else{
        return false;
      }
    }

    bool is_not_a_date_time()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_nan();
      }
      else{
        return false;
      }
    }


    impl_type get_rep()const
    {
      return ticks_;
    }

  protected:
    explicit time_duration(impl_type in) : ticks_(in) {}
    impl_type ticks_;
  };







  template<class base_duration, boost::int64_t frac_of_second>
  class subsecond_duration : public base_duration
  {
  public:
    typedef typename base_duration::impl_type impl_type;
    typedef typename base_duration::traits_type traits_type;

  private:

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0) == 0 ? false : true) >)> boost_static_assert_typedef_275
                                                                                             ;
    static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);

  public:
    explicit subsecond_duration(boost::int64_t ss) :
      base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
    {
    }
  };



} }
# 17 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_resolution_traits.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/time_resolution_traits.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/int_adapter.hpp" 1 3 4
# 21 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
namespace boost {
namespace date_time {
# 39 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
template<typename int_type_>
class int_adapter {
public:
  typedef int_type_ int_type;
  int_adapter(int_type v) :
    value_(v)
  {}
  static bool has_infinity()
  {
    return true;
  }
  static const int_adapter pos_infinity()
  {
    return (::std::numeric_limits<int_type>::max)();
  }
  static const int_adapter neg_infinity()
  {
    return (::std::numeric_limits<int_type>::min)();
  }
  static const int_adapter not_a_number()
  {
    return (::std::numeric_limits<int_type>::max)()-1;
  }
  static int_adapter max ()
  {
    return (::std::numeric_limits<int_type>::max)()-2;
  }
  static int_adapter min ()
  {
    return (::std::numeric_limits<int_type>::min)()+1;
  }
  static int_adapter from_special(special_values sv)
  {
    switch (sv) {
    case not_a_date_time: return not_a_number();
    case neg_infin: return neg_infinity();
    case pos_infin: return pos_infinity();
    case max_date_time: return (max)();
    case min_date_time: return (min)();
    default: return not_a_number();
    }
  }
  static bool is_inf(int_type v)
  {
    return (v == neg_infinity().as_number() ||
            v == pos_infinity().as_number());
  }
  static bool is_neg_inf(int_type v)
  {
    return (v == neg_infinity().as_number());
  }
  static bool is_pos_inf(int_type v)
  {
    return (v == pos_infinity().as_number());
  }
  static bool is_not_a_number(int_type v)
  {
    return (v == not_a_number().as_number());
  }

  static special_values to_special(int_type v)
  {
    if (is_not_a_number(v)) return not_a_date_time;
    if (is_neg_inf(v)) return neg_infin;
    if (is_pos_inf(v)) return pos_infin;
    return not_special;
  }


  static int_type maxcount()
  {
    return (::std::numeric_limits<int_type>::max)()-3;
  }
  bool is_infinity() const
  {
    return (value_ == neg_infinity().as_number() ||
            value_ == pos_infinity().as_number());
  }
  bool is_pos_infinity()const
  {
    return(value_ == pos_infinity().as_number());
  }
  bool is_neg_infinity()const
  {
    return(value_ == neg_infinity().as_number());
  }
  bool is_nan() const
  {
    return (value_ == not_a_number().as_number());
  }
  bool is_special() const
  {
    return(is_infinity() || is_nan());
  }
  bool operator==(const int_adapter& rhs) const
  {
    return (compare(rhs) == 0);
  }
  bool operator==(const int& rhs) const
  {

    bool is_signed = std::numeric_limits<int_type>::is_signed;
    if(!is_signed)
    {
      if(is_neg_inf(value_) && rhs == 0)
      {
        return false;
      }
    }
    return (compare(rhs) == 0);
  }
  bool operator!=(const int_adapter& rhs) const
  {
    return (compare(rhs) != 0);
  }
  bool operator!=(const int& rhs) const
  {

    bool is_signed = std::numeric_limits<int_type>::is_signed;
    if(!is_signed)
    {
      if(is_neg_inf(value_) && rhs == 0)
      {
        return true;
      }
    }
    return (compare(rhs) != 0);
  }
  bool operator<(const int_adapter& rhs) const
  {
    return (compare(rhs) == -1);
  }
  bool operator<(const int& rhs) const
  {

    bool is_signed = std::numeric_limits<int_type>::is_signed;
    if(!is_signed)
    {
      if(is_neg_inf(value_) && rhs == 0)
      {
        return true;
      }
    }
    return (compare(rhs) == -1);
  }
  bool operator>(const int_adapter& rhs) const
  {
    return (compare(rhs) == 1);
  }
  int_type as_number() const
  {
    return value_;
  }

  special_values as_special() const
  {
    return int_adapter::to_special(value_);
  }
# 205 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
  template<class rhs_type>
  inline
  int_adapter operator+(const int_adapter<rhs_type>& rhs) const
  {
    if(is_special() || rhs.is_special())
    {
      if (is_nan() || rhs.is_nan())
      {
        return int_adapter::not_a_number();
      }
      if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ||
      (is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) )
      {
        return int_adapter::not_a_number();
      }
      if (is_infinity())
      {
        return *this;
      }
      if (rhs.is_pos_inf(rhs.as_number()))
      {
        return int_adapter::pos_infinity();
      }
      if (rhs.is_neg_inf(rhs.as_number()))
      {
        return int_adapter::neg_infinity();
      }
    }
    return int_adapter<int_type>(value_ + rhs.as_number());
  }

  int_adapter operator+(const int_type rhs) const
  {
    if(is_special())
    {
      if (is_nan())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if (is_infinity())
      {
        return *this;
      }
    }
    return int_adapter<int_type>(value_ + rhs);
  }



  template<class rhs_type>
  inline
  int_adapter operator-(const int_adapter<rhs_type>& rhs)const
  {
    if(is_special() || rhs.is_special())
    {
      if (is_nan() || rhs.is_nan())
      {
        return int_adapter::not_a_number();
      }
      if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ||
         (is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) )
      {
        return int_adapter::not_a_number();
      }
      if (is_infinity())
      {
        return *this;
      }
      if (rhs.is_pos_inf(rhs.as_number()))
      {
        return int_adapter::neg_infinity();
      }
      if (rhs.is_neg_inf(rhs.as_number()))
      {
        return int_adapter::pos_infinity();
      }
    }
    return int_adapter<int_type>(value_ - rhs.as_number());
  }
  int_adapter operator-(const int_type rhs) const
  {
    if(is_special())
    {
      if (is_nan())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if (is_infinity())
      {
        return *this;
      }
    }
    return int_adapter<int_type>(value_ - rhs);
  }


  int_adapter operator*(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ * rhs.value_);
  }


  int_adapter operator*(const int rhs) const
  {
    if(is_special())
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ * rhs);
  }


  int_adapter operator/(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      if(is_infinity() && rhs.is_infinity())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if(rhs != 0)
      {
        return mult_div_specials(rhs);
      }
      else {
        return int_adapter<int_type>(value_ / rhs.value_);
      }
    }
    return int_adapter<int_type>(value_ / rhs.value_);
  }


  int_adapter operator/(const int rhs) const
  {
    if(is_special() && rhs != 0)
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ / rhs);
  }


  int_adapter operator%(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      if(is_infinity() && rhs.is_infinity())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if(rhs != 0)
      {
        return mult_div_specials(rhs);
      }
      else {
        return int_adapter<int_type>(value_ % rhs.value_);
      }
    }
    return int_adapter<int_type>(value_ % rhs.value_);
  }


  int_adapter operator%(const int rhs) const
  {
    if(is_special() && rhs != 0)
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ % rhs);
  }
private:
  int_type value_;


  int compare(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      if(this->is_nan() || rhs.is_nan()) {
        if(this->is_nan() && rhs.is_nan()) {
          return 0;
        }
        else {
          return 2;
        }
      }
      if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) ||
         (is_pos_inf(rhs.value_) && !is_pos_inf(value_)) )
        {
          return -1;
        }
      if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) ||
         (is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) {
        return 1;
      }
    }
    if(value_ < rhs.value_) return -1;
    if(value_ > rhs.value_) return 1;

    return 0;
  }





  int_adapter mult_div_specials(const int_adapter& rhs)const
  {
    int min_value;

    bool is_signed = std::numeric_limits<int_type>::is_signed;
    if(is_signed) {
      min_value = 0;
    }
    else {
      min_value = 1;
    }
    if(this->is_nan() || rhs.is_nan()) {
      return int_adapter<int_type>(not_a_number());
    }
    if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
        return int_adapter<int_type>(pos_infinity());
    }
    if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) {
        return int_adapter<int_type>(neg_infinity());
    }

    return int_adapter<int_type>(not_a_number());
  }






  int_adapter mult_div_specials(const int& rhs) const
  {
    int min_value;

    bool is_signed = std::numeric_limits<int_type>::is_signed;
    if(is_signed) {
      min_value = 0;
    }
    else {
      min_value = 1;
    }
    if(this->is_nan()) {
      return int_adapter<int_type>(not_a_number());
    }
    if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
        return int_adapter<int_type>(pos_infinity());
    }
    if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) {
        return int_adapter<int_type>(neg_infinity());
    }

    return int_adapter<int_type>(not_a_number());
  }

};






  template<class charT, class traits, typename int_type>
  inline
  std::basic_ostream<charT, traits>&
  operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
  {
    if(ia.is_special()) {

      switch(ia.as_special())
        {
      case not_a_date_time:
        os << "not-a-number";
        break;
      case pos_infin:
        os << "+infinity";
        break;
      case neg_infin:
        os << "-infinity";
        break;
      default:
        os << "";
      }
    }
    else {
      os << ia.as_number();
    }
    return os;
  }



} }
# 16 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4


namespace boost {
namespace date_time {


  template <typename T>


  inline T absolute_value(T x)
  {
    return x < 0 ? -x : x;
  }


  struct time_resolution_traits_bi32_impl {
    typedef boost::int32_t int_type;
    typedef boost::int32_t impl_type;
    static int_type as_number(impl_type i){ return i;}

    static bool is_adapted() { return false;}
  };

  struct time_resolution_traits_adapted32_impl {
    typedef boost::int32_t int_type;
    typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
    static int_type as_number(impl_type i){ return i.as_number();}

    static bool is_adapted() { return true;}
  };

  struct time_resolution_traits_bi64_impl {
    typedef boost::int64_t int_type;
    typedef boost::int64_t impl_type;
    static int_type as_number(impl_type i){ return i;}

    static bool is_adapted() { return false;}
  };

  struct time_resolution_traits_adapted64_impl {
    typedef boost::int64_t int_type;
    typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
    static int_type as_number(impl_type i){ return i.as_number();}

    static bool is_adapted() { return true;}
  };

  template<typename frac_sec_type,
           time_resolutions res,



           typename frac_sec_type::int_type resolution_adjust,

           unsigned short frac_digits,
           typename v_type = boost::int32_t >
  class time_resolution_traits {
  public:
    typedef typename frac_sec_type::int_type fractional_seconds_type;
    typedef typename frac_sec_type::int_type tick_type;
    typedef typename frac_sec_type::impl_type impl_type;
    typedef v_type day_type;
    typedef v_type hour_type;
    typedef v_type min_type;
    typedef v_type sec_type;


    static fractional_seconds_type as_number(impl_type i)
    {
      return frac_sec_type::as_number(i);
    }
    static bool is_adapted()
    {
      return frac_sec_type::is_adapted();
    }





    static const fractional_seconds_type ticks_per_second = resolution_adjust;


    static time_resolutions resolution()
    {
      return res;
    }
    static unsigned short num_fractional_digits()
    {
      return frac_digits;
    }
    static fractional_seconds_type res_adjust()
    {
      return resolution_adjust;
    }

    static tick_type to_tick_count(hour_type hours,
                                   min_type minutes,
                                   sec_type seconds,
                                   fractional_seconds_type fs)
    {
      if(hours < 0 || minutes < 0 || seconds < 0 || fs < 0)
      {
        hours = absolute_value(hours);
        minutes = absolute_value(minutes);
        seconds = absolute_value(seconds);
        fs = absolute_value(fs);
        return (((((fractional_seconds_type(hours)*3600)
                   + (fractional_seconds_type(minutes)*60)
                   + seconds)*res_adjust()) + fs) * -1);
      }

      return (((fractional_seconds_type(hours)*3600)
               + (fractional_seconds_type(minutes)*60)
               + seconds)*res_adjust()) + fs;
    }

  };

  typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
  typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
  typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;


} }
# 18 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/date.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/date.hpp" 3 4
# 1 "/usr/include/boost/date_time/year_month_day.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/year_month_day.hpp" 3 4
namespace boost {
namespace date_time {


  template<typename YearType, typename MonthType, typename DayType>
  struct year_month_day_base {
    year_month_day_base(YearType year,
                        MonthType month,
                        DayType day);
    YearType year;
    MonthType month;
    DayType day;
    typedef YearType year_type;
    typedef MonthType month_type;
    typedef DayType day_type;
  };



  template<typename YearType, typename MonthType, typename DayType>
  inline
  year_month_day_base<YearType,MonthType,DayType>::year_month_day_base(YearType y,
                                                                       MonthType m,
                                                                       DayType d) :
    year(y),
    month(m),
    day(d)
  {}

} }
# 14 "/usr/include/boost/date_time/date.hpp" 2 3 4


namespace boost {
namespace date_time {
# 52 "/usr/include/boost/date_time/date.hpp" 3 4
  template<class T, class calendar, class duration_type_>
  class date : private
       boost::less_than_comparable<T
     , boost::equality_comparable<T
    > >
  {
  public:
    typedef T date_type;
    typedef calendar calendar_type;
    typedef typename calendar::date_traits_type traits_type;
    typedef duration_type_ duration_type;
    typedef typename calendar::year_type year_type;
    typedef typename calendar::month_type month_type;
    typedef typename calendar::day_type day_type;
    typedef typename calendar::ymd_type ymd_type;
    typedef typename calendar::date_rep_type date_rep_type;
    typedef typename calendar::date_int_type date_int_type;
    typedef typename calendar::day_of_week_type day_of_week_type;
    date(year_type y, month_type m, day_type d)
      : days_(calendar::day_number(ymd_type(y, m, d)))
    {}
    date(const ymd_type& ymd)
      : days_(calendar::day_number(ymd))
    {}

    year_type year() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.year;
    }
    month_type month() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.month;
    }
    day_type day() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.day;
    }
    day_of_week_type day_of_week() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return calendar::day_of_week(ymd);
    }
    ymd_type year_month_day() const
    {
      return calendar::from_day_number(days_);
    }
    bool operator<(const date_type& rhs) const
    {
      return days_ < rhs.days_;
    }
    bool operator==(const date_type& rhs) const
    {
      return days_ == rhs.days_;
    }

    bool is_special()const
    {
      return(is_not_a_date() || is_infinity());
    }

    bool is_not_a_date() const
    {
      return traits_type::is_not_a_number(days_);
    }

    bool is_infinity() const
    {
      return traits_type::is_inf(days_);
    }

    bool is_pos_infinity() const
    {
      return traits_type::is_pos_inf(days_);
    }

    bool is_neg_infinity() const
    {
      return traits_type::is_neg_inf(days_);
    }

    special_values as_special() const
    {
      return traits_type::to_special(days_);
    }
    duration_type operator-(const date_type& d) const
    {
      if (!this->is_special() && !d.is_special())
      {


        typedef typename duration_type::duration_rep_type duration_rep_type;
        return duration_type(static_cast< duration_rep_type >(days_) - static_cast< duration_rep_type >(d.days_));
      }
      else
      {

        date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_);
        return duration_type(val.as_special());
      }
    }

    date_type operator-(const duration_type& dd) const
    {
      if(dd.is_special())
      {
        return date_type(date_rep_type(days_) - dd.get_rep());
      }
      return date_type(date_rep_type(days_) - dd.days());
    }
    date_type operator-=(const duration_type& dd)
    {
      *this = *this - dd;
      return date_type(days_);
    }
    date_rep_type day_count() const
    {
      return days_;
    }

    date_type operator+(const duration_type& dd) const
    {
      if(dd.is_special())
      {
        return date_type(date_rep_type(days_) + dd.get_rep());
      }
      return date_type(date_rep_type(days_) + dd.days());
    }
    date_type operator+=(const duration_type& dd)
    {
      *this = *this + dd;
      return date_type(days_);
    }


  protected:




    explicit date(date_int_type days) : days_(days) {}
    explicit date(date_rep_type days) : days_(days.as_number()) {}
    date_int_type days_;

  };




} }
# 18 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/period.hpp" 1 3 4
# 23 "/usr/include/boost/date_time/period.hpp" 3 4
namespace boost {
namespace date_time {
# 50 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  class period : private
      boost::less_than_comparable<period<point_rep, duration_rep>
    , boost::equality_comparable< period<point_rep, duration_rep>
    > >
  {
  public:
    typedef point_rep point_type;
    typedef duration_rep duration_type;

    period(point_rep first_point, point_rep end_point);
    period(point_rep first_point, duration_rep len);
    point_rep begin() const;
    point_rep end() const;
    point_rep last() const;
    duration_rep length() const;
    bool is_null() const;
    bool operator==(const period& rhs) const;
    bool operator<(const period& rhs) const;
    void shift(const duration_rep& d);
    void expand(const duration_rep& d);
    bool contains(const point_rep& point) const;
    bool contains(const period& other) const;
    bool intersects(const period& other) const;
    bool is_adjacent(const period& other) const;
    bool is_before(const point_rep& point) const;
    bool is_after(const point_rep& point) const;
    period intersection(const period& other) const;
    period merge(const period& other) const;
    period span(const period& other) const;
  private:
    point_rep begin_;
    point_rep last_;
  };




  template<class point_rep, class duration_rep>
  inline
  period<point_rep,duration_rep>::period(point_rep first_point,
                                         point_rep end_point) :
    begin_(first_point),
    last_(end_point - duration_rep::unit())
  {}




  template<class point_rep, class duration_rep>
  inline
  period<point_rep,duration_rep>::period(point_rep first_point, duration_rep len) :
    begin_(first_point),
    last_(first_point + len-duration_rep::unit())
  { }



  template<class point_rep, class duration_rep>
  inline
  point_rep period<point_rep,duration_rep>::begin() const
  {
    return begin_;
  }


  template<class point_rep, class duration_rep>
  inline
  point_rep period<point_rep,duration_rep>::end() const
  {
    return last_ + duration_rep::unit();
  }


  template<class point_rep, class duration_rep>
  inline
  point_rep period<point_rep,duration_rep>::last() const
  {
    return last_;
  }


  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::is_null() const
  {
    return end() <= begin_;
  }


  template<class point_rep, class duration_rep>
  inline
  duration_rep period<point_rep,duration_rep>::length() const
  {
    if(last_ < begin_){
      return last_+duration_rep::unit() - begin_;
    }
    else{
      return end() - begin_;
    }
  }


  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::operator==(const period& rhs) const
  {
    return ((begin_ == rhs.begin_) &&
             (last_ == rhs.last_));
  }


  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::operator<(const period& rhs) const
  {
    return (last_ < rhs.begin_);
  }



  template<class point_rep, class duration_rep>
  inline
  void period<point_rep,duration_rep>::shift(const duration_rep& d)
  {
    begin_ = begin_ + d;
    last_ = last_ + d;
  }
# 198 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  void period<point_rep,duration_rep>::expand(const duration_rep& d)
  {
    begin_ = begin_ - d;
    last_ = last_ + d;
  }


  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::contains(const point_rep& point) const
  {
    return ((point >= begin_) &&
            (point <= last_));
  }



  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::contains(const period<point_rep,duration_rep>& other) const
  {
    return ((begin_ <= other.begin_) && (last_ >= other.last_));
  }
# 234 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool
  period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const
  {
    return (other.begin() == end() ||
            begin_ == other.end());
  }
# 253 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool
  period<point_rep,duration_rep>::is_after(const point_rep& t) const
  {
    if (is_null())
    {
      return false;
    }

    return t < begin_;
  }
# 275 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool
  period<point_rep,duration_rep>::is_before(const point_rep& t) const
  {
    if (is_null())
    {
      return false;
    }

    return last_ < t;
  }
# 300 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const
  {
    return ( contains(other.begin_) ||
             other.contains(begin_) ||
             ((other.begin_ < begin_) && (other.last_ >= begin_)));
  }


  template<class point_rep, class duration_rep>
  inline
  period<point_rep,duration_rep>
  period<point_rep,duration_rep>::intersection(const period<point_rep,duration_rep>& other) const
  {
    if (begin_ > other.begin_) {
      if (last_ <= other.last_) {
        return *this;
      }

      return period<point_rep,duration_rep>(begin_, other.end());
    }
    else {
      if (last_ <= other.last_) {
        return period<point_rep,duration_rep>(other.begin_, this->end());
      }

      return other;
    }

  }




  template<class point_rep, class duration_rep>
  inline
  period<point_rep,duration_rep>
  period<point_rep,duration_rep>::merge(const period<point_rep,duration_rep>& other) const
  {
    if (this->intersects(other)) {
      if (begin_ < other.begin_) {
        return period<point_rep,duration_rep>(begin_, last_ > other.last_ ? this->end() : other.end());
      }

      return period<point_rep,duration_rep>(other.begin_, last_ > other.last_ ? this->end() : other.end());

    }
    return period<point_rep,duration_rep>(begin_,begin_);
  }
# 362 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline
  period<point_rep,duration_rep>
  period<point_rep,duration_rep>::span(const period<point_rep,duration_rep>& other) const
  {
    point_rep start((begin_ < other.begin_) ? begin() : other.begin());
    point_rep newend((last_ < other.last_) ? other.end() : this->end());
    return period<point_rep,duration_rep>(start, newend);
  }


} }
# 19 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 3 4
# 1 "/usr/include/boost/date_time/constrained_value.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
# 1 "/usr/include/boost/mpl/if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/if.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/static_cast.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/static_cast.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/config/integral.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/integral.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 73 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename T > struct value_type_wknd
{
    typedef typename T::value_type type;
};
# 87 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
}}}
# 18 "/usr/include/boost/mpl/if.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
# 1 "/usr/include/boost/mpl/lambda_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/lambda_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/void_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/void_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
# 18 "/usr/include/boost/mpl/void_fwd.hpp" 2 3 4

namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/na.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
# 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/bool.hpp" 3 4
# 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
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_; } }
# 18 "/usr/include/boost/mpl/bool.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4

namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
# 19 "/usr/include/boost/mpl/bool.hpp" 2 3 4


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;


}
# 18 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 3 4
namespace mpl_ {


struct na
{
    typedef na type;
    enum { value = 0 };
};

}
namespace boost { namespace mpl { using ::mpl_::na; } }
# 19 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4

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;
};
# 93 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
}}
# 19 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/int.hpp" 3 4
# 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4

namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/usr/include/boost/mpl/int.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/cat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/cat.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< int N >
struct int_
{
    static const int value = N;





    typedef int_ type;

    typedef int value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    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;


}
# 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 26 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4

namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Arity = int_< aux::template_arity<T>::value >


    >
struct lambda;

}}
# 19 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/arity.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/arity.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/arity.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/comma_if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 16 "/usr/include/boost/preprocessor/comma_if.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/repeat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 16 "/usr/include/boost/preprocessor/repeat.hpp" 2 3 4
# 47 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/inc.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/inc.hpp" 2 3 4
# 48 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
# 1 "/usr/include/boost/mpl/limits/arity.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4




# 1 "/usr/include/boost/preprocessor/logical/and.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/logical/and.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/logical/and.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/identity.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/identity.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/identity.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/empty.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 66 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 41 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/list/adt.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/check.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/compl.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
# 42 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 22 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 37 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/reverse.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
# 38 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 23 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 48 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
# 49 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/facilities/overload.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/variadic/size.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
# 23 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 22 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 67 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
# 68 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 29 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4






# 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
# 36 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/if.hpp" 2 3 4




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;

   
};
# 131 "/usr/include/boost/mpl/if.hpp" 3 4
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> { }; }

}}
# 17 "/usr/include/boost/date_time/constrained_value.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_base_of.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/is_base_of.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
# 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
# 1 "/usr/include/boost/type_traits/config.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 192 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_same.hpp" 1 3 4
# 31 "/usr/include/boost/type_traits/is_same.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
# 11 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
# 1 "/usr/include/boost/mpl/integral_c.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/usr/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/integral_c_fwd.hpp" 3 4
namespace mpl_ {





template< typename T, T N > struct integral_c;


}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
# 18 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
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;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    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;


}
# 33 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4




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; }
};
}
# 12 "/usr/include/boost/type_traits/integral_constant.hpp" 2 3 4

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;

}
# 16 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 32 "/usr/include/boost/type_traits/is_same.hpp" 2 3 4

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: };
# 98 "/usr/include/boost/type_traits/is_same.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 101 "/usr/include/boost/type_traits/is_same.hpp" 2 3 4
# 193 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_reference.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 1 3 4
# 32 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 33 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 2 3 4

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: };
# 113 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 116 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 2 3 4

namespace boost {

template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };




}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 27 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/ice.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/ice.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 3 4
namespace boost {
namespace type_traits {

typedef char yes_type;
struct no_type
{
   char padding[8];
};

}
}
# 15 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_or.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/detail/ice_or.hpp" 3 4
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;
};

}
}
# 16 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_and.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/ice_and.hpp" 3 4
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;
};

}
}
# 17 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_not.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/detail/ice_not.hpp" 3 4
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;
};

}
}
# 18 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 3 4
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;


}
}
# 19 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
# 19 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4

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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
# 194 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_volatile.hpp" 1 3 4
# 28 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 1 3 4
# 23 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
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;
};
# 92 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
}
}
# 29 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4
# 40 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 41 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4

namespace boost {

namespace detail{
template <class T>
struct is_volatile_rval_filter
{



   static const bool value = ::boost::detail::cv_traits_imp<T*>::is_volatile;

};
# 65 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
}






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: };
# 148 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 151 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4
# 195 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
# 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
# 1 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 1 3 4
# 95 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 3 4















# 15 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4




# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 20 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4

namespace boost {



namespace detail{

template <class T>
struct rvalue_ref_filter_rem_cv
{
   typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
};
# 52 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
}



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]; };
# 80 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 83 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 25 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4

namespace boost {

namespace detail {
# 222 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
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: };






}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 253 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
# 37 "/usr/include/boost/type_traits/is_class.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 38 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4

namespace boost {

namespace detail {
# 120 "/usr/include/boost/type_traits/is_class.hpp" 3 4
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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 139 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4




# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4

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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 50 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
# 18 "/usr/include/boost/date_time/constrained_value.hpp" 2 3 4

namespace boost {


namespace CV {

  enum violation_enum {min_violation, max_violation};
# 41 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
  template<class value_policies>
  class constrained_value {
  public:
    typedef typename value_policies::value_type value_type;

    constrained_value(value_type value) : value_((min)())
    {
      assign(value);
    }
    constrained_value& operator=(value_type v)
    {
      assign(v);
      return *this;
    }

    static value_type max () {return (value_policies::max)();}

    static value_type min () {return (value_policies::min)();}

    operator value_type() const {return value_;}
  protected:
    value_type value_;
  private:
    void assign(value_type value)
    {


      if (value+1 < (min)()+1) {
        value_policies::on_error(value_, value, min_violation);
        return;
      }
      if (value > (max)()) {
        value_policies::on_error(value_, value, max_violation);
        return;
      }
      value_ = value;
    }
};


  template<typename rep_type, rep_type min_value,
           rep_type max_value, class exception_type>
  class simple_exception_policy
  {
    struct exception_wrapper : public exception_type
    {




      operator std::out_of_range () const
      {

        return std::out_of_range("constrained value boundary has been violated");
      }
    };

    typedef typename mpl::if_<
      is_base_of< std::exception, exception_type >,
      exception_type,
      exception_wrapper
    >::type actual_exception_type;

  public:
    typedef rep_type value_type;
    static rep_type min () { return min_value; }
    static rep_type max () { return max_value; }
    static void on_error(rep_type, rep_type, violation_enum)
    {
      boost::throw_exception(actual_exception_type());
    }
  };



} }
# 13 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_defs.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/date_defs.hpp" 3 4
namespace boost {
namespace date_time {


  enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};


  enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};

} }
# 14 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4




namespace boost {
namespace gregorian {


  using date_time::Sunday;
  using date_time::Monday;
  using date_time::Tuesday;
  using date_time::Wednesday;
  using date_time::Thursday;
  using date_time::Friday;
  using date_time::Saturday;



  struct bad_weekday : public std::out_of_range
  {
    bad_weekday() : std::out_of_range(std::string("Weekday is out of range 0..6")) {}
  };
  typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
  typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;



  class greg_weekday : public greg_weekday_rep {
  public:
    typedef boost::date_time::weekdays weekday_enum;
    greg_weekday(unsigned short day_of_week_num) :
      greg_weekday_rep(day_of_week_num)
    {}

    unsigned short as_number() const {return value_;}
    const char* as_short_string() const;
    const char* as_long_string() const;

    const wchar_t* as_short_wstring() const;
    const wchar_t* as_long_wstring() const;

    weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}


  };



} }
# 14 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 3 4
namespace boost {
namespace gregorian {


  struct bad_day_of_year : public std::out_of_range
  {
    bad_day_of_year() :
      std::out_of_range(std::string("Day of year value is out of range 1..366"))
    {}
  };


  typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;


  typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;


} }
# 15 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian_calendar.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
namespace boost {
namespace date_time {
# 27 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
  template<typename ymd_type_, typename date_int_type_>
  class gregorian_calendar_base {
  public:

    typedef ymd_type_ ymd_type;

    typedef typename ymd_type::month_type month_type;

    typedef typename ymd_type::day_type day_type;

    typedef typename ymd_type::year_type year_type;

    typedef date_int_type_ date_int_type;


    static unsigned short day_of_week(const ymd_type& ymd);
    static int week_number(const ymd_type&ymd);

    static date_int_type day_number(const ymd_type& ymd);
    static date_int_type julian_day_number(const ymd_type& ymd);
    static date_int_type modjulian_day_number(const ymd_type& ymd);
    static ymd_type from_day_number(date_int_type);
    static ymd_type from_julian_day_number(date_int_type);
    static ymd_type from_modjulian_day_number(date_int_type);
    static bool is_leap_year(year_type);
    static unsigned short end_of_month_day(year_type y, month_type m);
    static ymd_type epoch();
    static unsigned short days_in_week();

  };



} }


# 1 "/usr/include/boost/date_time/gregorian_calendar.ipp" 1 3 4
# 14 "/usr/include/boost/date_time/gregorian_calendar.ipp" 3 4
namespace boost {
namespace date_time {



  template<typename ymd_type_, typename date_int_type_>
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
    unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
    unsigned short y = static_cast<unsigned short>(ymd.year - a);
    unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 2);
    unsigned short d = static_cast<unsigned short>((ymd.day + y + (y/4) - (y/100) + (y/400) + (31*m)/12) % 7);

    return d;
  }







  template<typename ymd_type_, typename date_int_type_>
  inline
  int
  gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
    unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
    unsigned long juliantoday = julian_day_number(ymd);
    unsigned long day = (julianbegin + 3) % 7;
    unsigned long week = (juliantoday + day - julianbegin + 4)/7;

    if ((week >= 1) && (week <= 52)) {
      return week;
    }

    if (week == 53) {
      if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
        return week;
      } else {
        return 1;
      }
    }

    else if (week == 0) {
      julianbegin = julian_day_number(ymd_type(static_cast<unsigned short>(ymd.year-1),1,1));
      juliantoday = julian_day_number(ymd);
      day = (julianbegin + 3) % 7;
      week = (juliantoday + day - julianbegin + 4)/7;
      return week;
    }

    return week;

  }




  template<typename ymd_type_, typename date_int_type_>
  inline
  date_int_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
  {
    unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
    unsigned short y = static_cast<unsigned short>(ymd.year + 4800 - a);
    unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 3);
    unsigned long d = ymd.day + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
    return d;
  }




  template<typename ymd_type_, typename date_int_type_>
  inline
  date_int_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
  {
    return day_number(ymd);
  }





  template<typename ymd_type_, typename date_int_type_>
  inline
  date_int_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
  {
    return julian_day_number(ymd)-2400001;
  }


  template<typename ymd_type_, typename date_int_type_>
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
  {
    date_int_type a = dayNumber + 32044;
    date_int_type b = (4*a + 3)/146097;
    date_int_type c = a-((146097*b)/4);
    date_int_type d = (4*c + 3)/1461;
    date_int_type e = c - (1461*d)/4;
    date_int_type m = (5*e + 2)/153;
    unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
    unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
    year_type year = static_cast<unsigned short>(100*b + d - 4800 + (m/10));


    return ymd_type(static_cast<unsigned short>(year),month,day);
  }


  template<typename ymd_type_, typename date_int_type_>
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
  {
    date_int_type a = dayNumber + 32044;
    date_int_type b = (4*a+3)/146097;
    date_int_type c = a - ((146097*b)/4);
    date_int_type d = (4*c + 3)/1461;
    date_int_type e = c - ((1461*d)/4);
    date_int_type m = (5*e + 2)/153;
    unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
    unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
    year_type year = static_cast<year_type>(100*b + d - 4800 + (m/10));


    return ymd_type(year,month,day);
  }


  template<typename ymd_type_, typename date_int_type_>
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(date_int_type dayNumber) {
    date_int_type jd = dayNumber + 2400001;
    return from_julian_day_number(jd);
  }





  template<typename ymd_type_, typename date_int_type_>
  inline
  bool
  gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
  {

    return (!(year % 4)) && ((year % 100) || (!(year % 400)));
  }





  template<typename ymd_type_, typename date_int_type_>
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
                                                                      month_type month)
  {
    switch (month) {
    case 2:
      if (is_leap_year(year)) {
        return 29;
      } else {
        return 28;
      };
    case 4:
    case 6:
    case 9:
    case 11:
      return 30;
    default:
      return 31;
    };

  }


  template<typename ymd_type_, typename date_int_type_>
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
  {
    return ymd_type(1400,1,1);
  }


  template<typename ymd_type_, typename date_int_type_>
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
  {
    return 7;
  }


} }
# 64 "/usr/include/boost/date_time/gregorian_calendar.hpp" 2 3 4
# 16 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 3 4
namespace boost {
namespace gregorian {


  struct bad_day_of_month : public std::out_of_range
  {
    bad_day_of_month() :
      std::out_of_range(std::string("Day of month value is out of range 1..31"))
    {}

    bad_day_of_month(const std::string& s) :
      std::out_of_range(s)
    {}
  };

  typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;


  typedef CV::constrained_value<greg_day_policies> greg_day_rep;







  class greg_day : public greg_day_rep {
  public:
    greg_day(unsigned short day_of_month) : greg_day_rep(day_of_month) {}
    unsigned short as_number() const {return value_;}
    operator unsigned short() const {return value_;}
  private:

  };



} }
# 15 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
namespace boost {
namespace gregorian {


  struct bad_year : public std::out_of_range
  {
    bad_year() :
      std::out_of_range(std::string("Year is out of valid range: 1400..10000"))
    {}
  };

  typedef CV::simple_exception_policy<unsigned short, 1400, 10000, bad_year> greg_year_policies;


  typedef CV::constrained_value<greg_year_policies> greg_year_rep;
# 39 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
  class greg_year : public greg_year_rep {
  public:
    greg_year(unsigned short year) : greg_year_rep(year) {}
    operator unsigned short() const {return value_;}
  private:

  };



} }
# 16 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 3 4
# 1 "/usr/include/c++/4.8/map" 1 3 4
# 58 "/usr/include/c++/4.8/map" 3 4
       
# 59 "/usr/include/c++/4.8/map" 3

# 1 "/usr/include/c++/4.8/bits/stl_tree.h" 1 3
# 69 "/usr/include/c++/4.8/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 89 "/usr/include/c++/4.8/bits/stl_tree.h" 3
  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);
      }
# 426 "/usr/include/c++/4.8/bits/stl_tree.h" 3
      _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(); }
# 462 "/usr/include/c++/4.8/bits/stl_tree.h" 3
 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:
      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_unique_pos(const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_equal_pos(const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_hint_unique_pos(const_iterator __pos,
        const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_hint_equal_pos(const_iterator __pos,
       const key_type& __k);
# 611 "/usr/include/c++/4.8/bits/stl_tree.h" 3
      iterator
      _M_insert_(_Base_ptr __x, _Base_ptr __y,
   const value_type& __v);



      iterator
      _M_insert_lower(_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, _Node_allocator(__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);
# 771 "/usr/include/c++/4.8/bits/stl_tree.h" 3
      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:
# 824 "/usr/include/c++/4.8/bits/stl_tree.h" 3
      void
      erase(iterator __position)
      { _M_erase_aux(__position); }

      void
      erase(const_iterator __position)
      { _M_erase_aux(__position); }

      size_type
      erase(const key_type& __x);
# 846 "/usr/include/c++/4.8/bits/stl_tree.h" 3
      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); }
# 984 "/usr/include/c++/4.8/bits/stl_tree.h" 3
  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_(_Base_ptr __x, _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, __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 __p, const _Val& __v)

    {
      bool __insert_left = (__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(__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>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_unique_pos(const key_type& __k)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      bool __comp = true;
      while (__x != 0)
 {
   __y = __x;
   __comp = _M_impl._M_key_compare(__k, _S_key(__x));
   __x = __comp ? _S_left(__x) : _S_right(__x);
 }
      iterator __j = iterator(__y);
      if (__comp)
 {
   if (__j == begin())
     return _Res(__x, __y);
   else
     --__j;
 }
      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
 return _Res(__x, __y);
      return _Res(__j._M_node, 0);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_equal_pos(const key_type& __k)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
         _S_left(__x) : _S_right(__x);
 }
      return _Res(__x, __y);
    }

  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)

    {
      typedef pair<iterator, bool> _Res;
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_unique_pos(_KeyOfValue()(__v));

      if (__res.second)
 return _Res(_M_insert_(__res.first, __res.second,
          (__v)),
      true);

      return _Res(iterator(static_cast<_Link_type>(__res.first)), 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)

    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_equal_pos(_KeyOfValue()(__v));
      return _M_insert_(__res.first, __res.second, (__v));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
         typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_hint_unique_pos(const_iterator __position,
      const key_type& __k)
    {
      iterator __pos = __position._M_const_cast();
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__pos._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
     return _Res(0, _M_rightmost());
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
 {

   iterator __before = __pos;
   if (__pos._M_node == _M_leftmost())
     return _Res(_M_leftmost(), _M_leftmost());
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
     {
       if (_S_right(__before._M_node) == 0)
  return _Res(0, __before._M_node);
       else
  return _Res(__pos._M_node, __pos._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
 {

   iterator __after = __pos;
   if (__pos._M_node == _M_rightmost())
     return _Res(0, _M_rightmost());
   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
     {
       if (_S_right(__pos._M_node) == 0)
  return _Res(0, __pos._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else

 return _Res(__pos._M_node, 0);
    }

  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)

    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));

      if (__res.second)
 return _M_insert_(__res.first, __res.second,
     (__v));
      return iterator(static_cast<_Link_type>(__res.first));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
         typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
    {
      iterator __pos = __position._M_const_cast();
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__pos._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
     return _Res(0, _M_rightmost());
   else
     return _M_get_insert_equal_pos(__k);
 }
      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
 {

   iterator __before = __pos;
   if (__pos._M_node == _M_leftmost())
     return _Res(_M_leftmost(), _M_leftmost());
   else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _Res(0, __before._M_node);
       else
  return _Res(__pos._M_node, __pos._M_node);
     }
   else
     return _M_get_insert_equal_pos(__k);
 }
      else
 {

   iterator __after = __pos;
   if (__pos._M_node == _M_rightmost())
     return _Res(0, _M_rightmost());
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
     {
       if (_S_right(__pos._M_node) == 0)
  return _Res(0, __pos._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _Res(0, 0);
 }
    }

  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)

    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));

      if (__res.second)
 return _M_insert_(__res.first, __res.second,
     (__v));

      return _M_insert_equal_lower((__v));
    }
# 1714 "/usr/include/c++/4.8/bits/stl_tree.h" 3
  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;
    }


}
# 61 "/usr/include/c++/4.8/map" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_map.h" 1 3
# 66 "/usr/include/c++/4.8/bits/stl_map.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 94 "/usr/include/c++/4.8/bits/stl_map.h" 3
  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, _Pair_alloc_type(__a)) { }
# 180 "/usr/include/c++/4.8/bits/stl_map.h" 3
      map(const map& __x)
      : _M_t(__x._M_t) { }
# 223 "/usr/include/c++/4.8/bits/stl_map.h" 3
      template<typename _InputIterator>
        map(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_unique(__first, __last); }
# 240 "/usr/include/c++/4.8/bits/stl_map.h" 3
      template<typename _InputIterator>
        map(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Pair_alloc_type(__a))
        { _M_t._M_insert_unique(__first, __last); }
# 263 "/usr/include/c++/4.8/bits/stl_map.h" 3
      map&
      operator=(const map& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 309 "/usr/include/c++/4.8/bits/stl_map.h" 3
      allocator_type
      get_allocator() const
      { return allocator_type(_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(); }
# 428 "/usr/include/c++/4.8/bits/stl_map.h" 3
      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(); }
# 455 "/usr/include/c++/4.8/bits/stl_map.h" 3
      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;
      }
# 500 "/usr/include/c++/4.8/bits/stl_map.h" 3
      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;
      }
# 593 "/usr/include/c++/4.8/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__x); }
# 642 "/usr/include/c++/4.8/bits/stl_map.h" 3
      iterator



      insert(iterator __position, const value_type& __x)

      { return _M_t._M_insert_unique_(__position, __x); }
# 668 "/usr/include/c++/4.8/bits/stl_map.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_unique(__first, __last); }
# 709 "/usr/include/c++/4.8/bits/stl_map.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 725 "/usr/include/c++/4.8/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 761 "/usr/include/c++/4.8/bits/stl_map.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 777 "/usr/include/c++/4.8/bits/stl_map.h" 3
      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()); }
# 820 "/usr/include/c++/4.8/bits/stl_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 835 "/usr/include/c++/4.8/bits/stl_map.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 847 "/usr/include/c++/4.8/bits/stl_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 862 "/usr/include/c++/4.8/bits/stl_map.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 877 "/usr/include/c++/4.8/bits/stl_map.h" 3
      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); }
# 916 "/usr/include/c++/4.8/bits/stl_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 935 "/usr/include/c++/4.8/bits/stl_map.h" 3
      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>&);
    };
# 960 "/usr/include/c++/4.8/bits/stl_map.h" 3
  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; }
# 977 "/usr/include/c++/4.8/bits/stl_map.h" 3
  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); }


}
# 62 "/usr/include/c++/4.8/map" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_multimap.h" 1 3
# 64 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 92 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
  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, _Pair_alloc_type(__a)) { }
# 177 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      multimap(const multimap& __x)
      : _M_t(__x._M_t) { }
# 218 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_equal(__first, __last); }
# 234 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        multimap(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Pair_alloc_type(__a))
        { _M_t._M_insert_equal(__first, __last); }
# 257 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 303 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      allocator_type
      get_allocator() const
      { return allocator_type(_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(); }
# 420 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      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(); }
# 500 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 533 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      iterator



      insert(iterator __position, const value_type& __x)

      { return _M_t._M_insert_equal_(__position, __x); }
# 560 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_equal(__first, __last); }
# 614 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 630 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 670 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 686 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      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()); }
# 729 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 744 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      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); }
# 768 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 783 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      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); }
# 820 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }
# 837 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
      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>&);
  };
# 862 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
  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; }
# 879 "/usr/include/c++/4.8/bits/stl_multimap.h" 3
  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); }


}
# 63 "/usr/include/c++/4.8/map" 2 3
# 19 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cctype" 1 3 4
# 39 "/usr/include/c++/4.8/cctype" 3 4
       
# 40 "/usr/include/c++/4.8/cctype" 3
# 21 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 2 3 4

namespace boost {
namespace gregorian {

  typedef date_time::months_of_year months_of_year;


  using date_time::Jan;
  using date_time::Feb;
  using date_time::Mar;
  using date_time::Apr;
  using date_time::May;
  using date_time::Jun;
  using date_time::Jul;
  using date_time::Aug;
  using date_time::Sep;
  using date_time::Oct;
  using date_time::Nov;
  using date_time::Dec;
  using date_time::NotAMonth;
  using date_time::NumMonths;


  struct bad_month : public std::out_of_range
  {
    bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {}
  };

  typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;

  typedef CV::constrained_value<greg_month_policies> greg_month_rep;



  class greg_month : public greg_month_rep {
  public:
    typedef date_time::months_of_year month_enum;
    typedef std::map<std::string, unsigned short> month_map_type;
    typedef boost::shared_ptr<month_map_type> month_map_ptr_type;

    greg_month(month_enum theMonth) :
      greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}

    greg_month(unsigned short theMonth) : greg_month_rep(theMonth) {}

    operator unsigned short() const {return value_;}

    unsigned short as_number() const {return value_;}
    month_enum as_enum() const {return static_cast<month_enum>(value_);}
    const char* as_short_string() const;
    const char* as_long_string() const;

    const wchar_t* as_short_wstring() const;
    const wchar_t* as_long_wstring() const;


    static month_map_ptr_type get_month_map_ptr();



    const char* as_short_string(char) const
    {
      return as_short_string();
    }
    const char* as_long_string(char) const
    {
      return as_long_string();
    }

    const wchar_t* as_short_string(wchar_t) const
    {
      return as_short_wstring();
    }
    const wchar_t* as_long_string(wchar_t) const
    {
      return as_long_wstring();
    }

  };

} }
# 17 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4

namespace boost {
namespace gregorian {

  typedef date_time::year_month_day_base<greg_year,
                                         greg_month,
                                         greg_day> greg_year_month_day;



} }
# 17 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4


namespace boost {
namespace gregorian {


  typedef date_time::int_adapter<uint32_t> fancy_date_rep;


  class gregorian_calendar :
    public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
  public:

    typedef greg_weekday day_of_week_type;

    typedef greg_day_of_year_rep day_of_year_type;

    typedef fancy_date_rep date_rep_type;

    typedef fancy_date_rep date_traits_type;


  private:
  };

} }
# 20 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 3 4
# 1 "/usr/include/boost/date_time/date_duration.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/date_duration.hpp" 3 4
namespace boost {
namespace date_time {



  template<class duration_rep_traits>
  class date_duration : private
              boost::less_than_comparable1< date_duration< duration_rep_traits >
            , boost::equality_comparable1< date_duration< duration_rep_traits >
            , boost::addable1< date_duration< duration_rep_traits >
            , boost::subtractable1< date_duration< duration_rep_traits >
            , boost::dividable2< date_duration< duration_rep_traits >, int
            > > > > >
  {
  public:
    typedef typename duration_rep_traits::int_type duration_rep_type;
    typedef typename duration_rep_traits::impl_type duration_rep;


    explicit date_duration(duration_rep day_count) : days_(day_count) {}



    date_duration(special_values sv) :
            days_(duration_rep::from_special(sv))
    {}



    date_duration(const date_duration<duration_rep_traits>& other) :
            days_(other.days_)
    {}


    duration_rep get_rep()const
    {
        return days_;
    }
    bool is_special()const
    {
        return days_.is_special();
    }

    duration_rep_type days() const
    {
        return duration_rep_traits::as_number(days_);
    }

    static date_duration unit()
    {
        return date_duration<duration_rep_traits>(1);
    }

    bool operator==(const date_duration& rhs) const
    {
        return days_ == rhs.days_;
    }

    bool operator<(const date_duration& rhs) const
    {
        return days_ < rhs.days_;
    }







    date_duration& operator-=(const date_duration& rhs)
    {

        days_ = days_ - rhs.days_;
        return *this;
    }

    date_duration& operator+=(const date_duration& rhs)
    {
        days_ = days_ + rhs.days_;
        return *this;
    }


    date_duration operator-() const
    {
        return date_duration<duration_rep_traits>(get_rep() * (-1));
    }

    date_duration& operator/=(int divisor)
    {
        days_ = days_ / divisor;
        return *this;
    }


    bool is_negative() const
    {
        return days_ < 0;
    }

  private:
    duration_rep days_;
  };





  struct duration_traits_long
  {
    typedef long int_type;
    typedef long impl_type;
    static int_type as_number(impl_type i) { return i; }
  };




  struct duration_traits_adapted
  {
    typedef long int_type;
    typedef boost::date_time::int_adapter<long> impl_type;
    static int_type as_number(impl_type i) { return i.as_number(); }
  };


} }
# 13 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4



namespace boost {
namespace gregorian {


  typedef boost::date_time::duration_traits_adapted date_duration_rep;




  class date_duration :
    public boost::date_time::date_duration< date_duration_rep >
  {
    typedef boost::date_time::date_duration< date_duration_rep > base_type;

  public:
    typedef base_type::duration_rep duration_rep;


    explicit date_duration(duration_rep day_count = 0) : base_type(day_count) {}


    date_duration(date_time::special_values sv) : base_type(sv) {}


    date_duration(const date_duration& other) : base_type(static_cast< base_type const& >(other))
    {}


    date_duration(const base_type& other) : base_type(other)
    {}





    bool operator== (const date_duration& rhs) const
    {
      return base_type::operator== (rhs);
    }
    bool operator!= (const date_duration& rhs) const
    {
      return !operator== (rhs);
    }
    bool operator< (const date_duration& rhs) const
    {
      return base_type::operator< (rhs);
    }
    bool operator> (const date_duration& rhs) const
    {
      return !(base_type::operator< (rhs) || base_type::operator== (rhs));
    }
    bool operator<= (const date_duration& rhs) const
    {
      return (base_type::operator< (rhs) || base_type::operator== (rhs));
    }
    bool operator>= (const date_duration& rhs) const
    {
      return !base_type::operator< (rhs);
    }


    date_duration& operator-= (const date_duration& rhs)
    {
      base_type::operator-= (rhs);
      return *this;
    }
    friend date_duration operator- (date_duration rhs, date_duration const& lhs)
    {
      rhs -= lhs;
      return rhs;
    }


    date_duration& operator+= (const date_duration& rhs)
    {
      base_type::operator+= (rhs);
      return *this;
    }
    friend date_duration operator+ (date_duration rhs, date_duration const& lhs)
    {
      rhs += lhs;
      return rhs;
    }


    date_duration operator- ()const
    {
      return date_duration(get_rep() * (-1));
    }


    date_duration& operator/= (int divisor)
    {
      base_type::operator/= (divisor);
      return *this;
    }
    friend date_duration operator/ (date_duration rhs, int lhs)
    {
      rhs /= lhs;
      return rhs;
    }


    static date_duration unit()
    {
      return date_duration(base_type::unit().get_rep());
    }
  };


  typedef date_duration days;

} }


# 1 "/usr/include/boost/date_time/date_duration_types.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/date_duration_types.hpp" 3 4
namespace boost {
namespace date_time {



  template <class duration_config>
  class weeks_duration : public date_duration<duration_config> {
  public:
    weeks_duration(typename duration_config::impl_type w)
      : date_duration<duration_config>(w * 7) {}
    weeks_duration(special_values sv)
      : date_duration<duration_config>(sv) {}
  };


  template<class t>
  class years_duration;






  template<class base_config>
  class months_duration
  {
    private:
      typedef typename base_config::int_rep int_rep;
      typedef typename int_rep::int_type int_type;
      typedef typename base_config::date_type date_type;
      typedef typename date_type::duration_type duration_type;
      typedef typename base_config::month_adjustor_type month_adjustor_type;
      typedef months_duration<base_config> months_type;
      typedef years_duration<base_config> years_type;
    public:
      months_duration(int_rep num) : _m(num) {}
      months_duration(special_values sv) : _m(sv)
      {
        _m = int_rep::from_special(sv);
      }
      int_rep number_of_months() const { return _m; }

      duration_type get_neg_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_m.as_number());
        return duration_type(m_adj.get_neg_offset(d));
      }
      duration_type get_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_m.as_number());
        return duration_type(m_adj.get_offset(d));
      }
      bool operator==(const months_type& rhs) const
      {
        return(_m == rhs._m);
      }
      bool operator!=(const months_type& rhs) const
      {
        return(_m != rhs._m);
      }
      months_type operator+(const months_type& rhs)const
      {
        return months_type(_m + rhs._m);
      }
      months_type& operator+=(const months_type& rhs)
      {
        _m = _m + rhs._m;
        return *this;
      }
      months_type operator-(const months_type& rhs)const
      {
        return months_type(_m - rhs._m);
      }
      months_type& operator-=(const months_type& rhs)
      {
        _m = _m - rhs._m;
        return *this;
      }
      months_type operator*(const int_type rhs)const
      {
        return months_type(_m * rhs);
      }
      months_type& operator*=(const int_type rhs)
      {
        _m = _m * rhs;
        return *this;
      }
      months_type operator/(const int_type rhs)const
      {
        return months_type(_m / rhs);
      }
      months_type& operator/=(const int_type rhs)
      {
        _m = _m / rhs;
        return *this;
      }
      months_type operator+(const years_type& y)const
      {
        return months_type(y.number_of_years() * 12 + _m);
      }
      months_type& operator+=(const years_type& y)
      {
        _m = y.number_of_years() * 12 + _m;
        return *this;
      }
      months_type operator-(const years_type& y) const
      {
        return months_type(_m - y.number_of_years() * 12);
      }
      months_type& operator-=(const years_type& y)
      {
        _m = _m - y.number_of_years() * 12;
        return *this;
      }


      friend date_type operator+(const date_type& d, const months_type& m)
      {
        return d + m.get_offset(d);
      }
      friend date_type operator+=(date_type& d, const months_type& m)
      {
        return d += m.get_offset(d);
      }
      friend date_type operator-(const date_type& d, const months_type& m)
      {

        return d + m.get_neg_offset(d);
      }
      friend date_type operator-=(date_type& d, const months_type& m)
      {

        return d += m.get_neg_offset(d);
      }

    private:
      int_rep _m;
  };







  template<class base_config>
  class years_duration
  {
    private:
      typedef typename base_config::int_rep int_rep;
      typedef typename int_rep::int_type int_type;
      typedef typename base_config::date_type date_type;
      typedef typename date_type::duration_type duration_type;
      typedef typename base_config::month_adjustor_type month_adjustor_type;
      typedef years_duration<base_config> years_type;
      typedef months_duration<base_config> months_type;
    public:
      years_duration(int_rep num) : _y(num) {}
      years_duration(special_values sv) : _y(sv)
      {
        _y = int_rep::from_special(sv);
      }
      int_rep number_of_years() const { return _y; }

      duration_type get_neg_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_y.as_number() * 12);
        return duration_type(m_adj.get_neg_offset(d));
      }
      duration_type get_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_y.as_number() * 12);
        return duration_type(m_adj.get_offset(d));
      }
      bool operator==(const years_type& rhs) const
      {
        return(_y == rhs._y);
      }
      bool operator!=(const years_type& rhs) const
      {
        return(_y != rhs._y);
      }
      years_type operator+(const years_type& rhs)const
      {
        return years_type(_y + rhs._y);
      }
      years_type& operator+=(const years_type& rhs)
      {
        _y = _y + rhs._y;
        return *this;
      }
      years_type operator-(const years_type& rhs)const
      {
        return years_type(_y - rhs._y);
      }
      years_type& operator-=(const years_type& rhs)
      {
        _y = _y - rhs._y;
        return *this;
      }
      years_type operator*(const int_type rhs)const
      {
        return years_type(_y * rhs);
      }
      years_type& operator*=(const int_type rhs)
      {
        _y = _y * rhs;
        return *this;
      }
      years_type operator/(const int_type rhs)const
      {
        return years_type(_y / rhs);
      }
      years_type& operator/=(const int_type rhs)
      {
        _y = _y / rhs;
        return *this;
      }
      months_type operator+(const months_type& m) const
      {
        return(months_type(_y * 12 + m.number_of_months()));
      }
      months_type operator-(const months_type& m) const
      {
        return(months_type(_y * 12 - m.number_of_months()));
      }


      friend date_type operator+(const date_type& d, const years_type& y)
      {
        return d + y.get_offset(d);
      }
      friend date_type operator+=(date_type& d, const years_type& y)
      {
        return d += y.get_offset(d);
      }
      friend date_type operator-(const date_type& d, const years_type& y)
      {

        return d + y.get_neg_offset(d);
      }
      friend date_type operator-=(date_type& d, const years_type& y)
      {

        return d += y.get_neg_offset(d);
      }

    private:
      int_rep _y;
  };

}}
# 132 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
# 21 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
namespace boost {
namespace gregorian {


  using date_time::special_values;
  using date_time::not_special;
  using date_time::neg_infin;
  using date_time::pos_infin;
  using date_time::not_a_date_time;
  using date_time::max_date_time;
  using date_time::min_date_time;
# 37 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
  class date : public date_time::date<date, gregorian_calendar, date_duration>
  {
   public:
    typedef gregorian_calendar::year_type year_type;
    typedef gregorian_calendar::month_type month_type;
    typedef gregorian_calendar::day_type day_type;
    typedef gregorian_calendar::day_of_year_type day_of_year_type;
    typedef gregorian_calendar::ymd_type ymd_type;
    typedef gregorian_calendar::date_rep_type date_rep_type;
    typedef gregorian_calendar::date_int_type date_int_type;
    typedef date_duration duration_type;


    date():
      date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
    {}


    date(year_type y, month_type m, day_type d)
      : date_time::date<date, gregorian_calendar, date_duration>(y, m, d)
    {
      if (gregorian_calendar::end_of_month_day(y, m) < d) {
        boost::throw_exception(bad_day_of_month(std::string("Day of month is not valid for year")));
      }
    }

    explicit date(const ymd_type& ymd)
      : date_time::date<date, gregorian_calendar, date_duration>(ymd)
    {}

    explicit date(const date_int_type& rhs):
      date_time::date<date,gregorian_calendar, date_duration>(rhs)
    {}

    explicit date(date_rep_type rhs):
      date_time::date<date,gregorian_calendar, date_duration>(rhs)
    {}

    explicit date(special_values sv):
      date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(sv))
    {
      if (sv == min_date_time)
      {
        *this = date(1400, 1, 1);
      }
      if (sv == max_date_time)
      {
        *this = date(9999, 12, 31);
      }

    }

    date_int_type julian_day() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::julian_day_number(ymd);
    }

    day_of_year_type day_of_year() const
    {
      date start_of_year(year(), 1, 1);
      unsigned short doy = static_cast<unsigned short>((*this-start_of_year).days() + 1);
      return day_of_year_type(doy);
    }

    date_int_type modjulian_day() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::modjulian_day_number(ymd);
    }

    int week_number() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::week_number(ymd);
    }

    date_int_type day_number() const
    {
      return days_;
    }

    date end_of_month() const
    {
      ymd_type ymd = year_month_day();
      short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
      return date(ymd.year, ymd.month, eom_day);
    }

   private:

  };



} }
# 13 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/adjust_functors.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
# 1 "/usr/include/boost/date_time/wrapping_int.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
namespace boost {
namespace date_time {
# 30 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
template<typename int_type_, int_type_ wrap_val>
class wrapping_int {
public:
  typedef int_type_ int_type;

  static int_type wrap_value() {return wrap_val;}

  wrapping_int(int_type v) : value_(v) {}

  int_type as_int() const {return value_;}
  operator int_type() const {return value_;}





  template< typename IntT >
  IntT add(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_val));
    IntT overflow = static_cast<IntT>(v / (wrap_val));
    value_ = static_cast<int_type>(value_ + remainder);
    return calculate_wrap(overflow);
  }






  template< typename IntT >
  IntT subtract(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_val));
    IntT underflow = static_cast<IntT>(-(v / (wrap_val)));
    value_ = static_cast<int_type>(value_ - remainder);
    return calculate_wrap(underflow) * -1;
  }
private:
  int_type value_;

  template< typename IntT >
  IntT calculate_wrap(IntT wrap)
  {
    if ((value_) >= wrap_val)
    {
      ++wrap;
      value_ -= (wrap_val);
    }
    else if(value_ < 0)
    {
      --wrap;
      value_ += (wrap_val);
    }
    return wrap;
  }

};






template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
class wrapping_int2 {
public:
  typedef int_type_ int_type;
  static int_type wrap_value() {return wrap_max;}
  static int_type min_value() {return wrap_min;}


  wrapping_int2(int_type v) : value_(v) {
    if(value_ < wrap_min)
    {
      value_ = wrap_min;
    }
    if(value_ > wrap_max)
    {
      value_ = wrap_max;
    }
  }

  int_type as_int() const {return value_;}
  operator int_type() const {return value_;}





  template< typename IntT >
  IntT add(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
    IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1));
    value_ = static_cast<int_type>(value_ + remainder);
    return calculate_wrap(overflow);
  }





  template< typename IntT >
  IntT subtract(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
    IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1)));
    value_ = static_cast<int_type>(value_ - remainder);
    return calculate_wrap(underflow);
  }

private:
  int_type value_;

  template< typename IntT >
  IntT calculate_wrap(IntT wrap)
  {
    if ((value_) > wrap_max)
    {
      ++wrap;
      value_ -= (wrap_max - wrap_min + 1);
    }
    else if((value_) < wrap_min)
    {
      --wrap;
      value_ += (wrap_max - wrap_min + 1);
    }
    return wrap;
  }
};



} }
# 14 "/usr/include/boost/date_time/adjust_functors.hpp" 2 3 4

namespace boost {
namespace date_time {



  template<class date_type>
  class day_functor
  {
  public:
    typedef typename date_type::duration_type duration_type;
    day_functor(int f) : f_(f) {}
    duration_type get_offset(const date_type& d) const
    {


      d.year();
      return duration_type(f_);
    }
    duration_type get_neg_offset(const date_type& d) const
    {

      d.year();
      return duration_type(-f_);
    }
  private:
    int f_;
  };
# 53 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
  template<class date_type>
  class month_functor
  {
  public:
    typedef typename date_type::duration_type duration_type;
    typedef typename date_type::calendar_type cal_type;
    typedef typename cal_type::ymd_type ymd_type;
    typedef typename cal_type::day_type day_type;

    month_functor(int f) : f_(f), origDayOfMonth_(0) {}
    duration_type get_offset(const date_type& d) const
    {
      ymd_type ymd(d.year_month_day());
      if (origDayOfMonth_ == 0) {
        origDayOfMonth_ = ymd.day;
        day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
        if (endOfMonthDay == ymd.day) {
          origDayOfMonth_ = -1;
        }
      }
      typedef date_time::wrapping_int2<short,1,12> wrap_int2;
      typedef typename wrap_int2::int_type int_type;
      wrap_int2 wi(ymd.month);

      int_type year = wi.add(static_cast<int_type>(f_));
      year = static_cast<int_type>(year + ymd.year);



      day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));

      if (origDayOfMonth_ == -1) {
        return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
      }
      day_type dayOfMonth = origDayOfMonth_;
      if (dayOfMonth > resultingEndOfMonthDay) {
        dayOfMonth = resultingEndOfMonthDay;
      }
      return date_type(year, wi.as_int(), dayOfMonth) - d;
    }

    duration_type get_neg_offset(const date_type& d) const
    {
      ymd_type ymd(d.year_month_day());
      if (origDayOfMonth_ == 0) {
        origDayOfMonth_ = ymd.day;
        day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
        if (endOfMonthDay == ymd.day) {
          origDayOfMonth_ = -1;
        }
      }
      typedef date_time::wrapping_int2<short,1,12> wrap_int2;
      typedef typename wrap_int2::int_type int_type;
      wrap_int2 wi(ymd.month);

      int_type year = wi.subtract(static_cast<int_type>(f_));
      year = static_cast<int_type>(year + ymd.year);

      day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));

      if (origDayOfMonth_ == -1) {
        return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
      }
      day_type dayOfMonth = origDayOfMonth_;
      if (dayOfMonth > resultingEndOfMonthDay) {
        dayOfMonth = resultingEndOfMonthDay;
      }
      return date_type(year, wi.as_int(), dayOfMonth) - d;
    }
  private:
    int f_;
    mutable short origDayOfMonth_;
  };



  template<class date_type>
  class week_functor
  {
  public:
    typedef typename date_type::duration_type duration_type;
    typedef typename date_type::calendar_type calendar_type;
    week_functor(int f) : f_(f) {}
    duration_type get_offset(const date_type& d) const
    {


      d.year();
      return duration_type(f_*calendar_type::days_in_week());
    }
    duration_type get_neg_offset(const date_type& d) const
    {

      d.year();
      return duration_type(-f_*calendar_type::days_in_week());
    }
  private:
    int f_;
  };


  template<class date_type>
  class year_functor
  {
  public:

    typedef typename date_type::duration_type duration_type;
    year_functor(int f) : _mf(f * 12) {}
    duration_type get_offset(const date_type& d) const
    {
      return _mf.get_offset(d);
    }
    duration_type get_neg_offset(const date_type& d) const
    {
      return _mf.get_neg_offset(d);
    }
  private:
    month_functor<date_type> _mf;
  };


} }
# 15 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4



namespace boost {
namespace gregorian {


  struct greg_durations_config {
    typedef date date_type;
    typedef date_time::int_adapter<int> int_rep;
    typedef date_time::month_functor<date_type> month_adjustor_type;
  };

  typedef date_time::months_duration<greg_durations_config> months;
  typedef date_time::years_duration<greg_durations_config> years;

  class weeks_duration : public date_duration {
  public:
    weeks_duration(duration_rep w)
      : date_duration(w * 7) {}
    weeks_duration(date_time::special_values sv)
      : date_duration(sv) {}
  };

  typedef weeks_duration weeks;

}}
# 23 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/date_generators.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/date_generators.hpp" 3 4
# 1 "/usr/include/c++/4.8/sstream" 1 3 4
# 36 "/usr/include/c++/4.8/sstream" 3 4
       
# 37 "/usr/include/c++/4.8/sstream" 3




namespace std __attribute__ ((__visibility__ ("default")))
{

# 63 "/usr/include/c++/4.8/sstream" 3
  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:
# 97 "/usr/include/c++/4.8/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 110 "/usr/include/c++/4.8/sstream" 3
      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); }
# 125 "/usr/include/c++/4.8/sstream" 3
      __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;
      }
# 149 "/usr/include/c++/4.8/sstream" 3
      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());
# 201 "/usr/include/c++/4.8/sstream" 3
      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);
    };
# 271 "/usr/include/c++/4.8/sstream" 3
  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:
# 307 "/usr/include/c++/4.8/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 325 "/usr/include/c++/4.8/sstream" 3
      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()
      { }
# 347 "/usr/include/c++/4.8/sstream" 3
      __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); }
    };
# 386 "/usr/include/c++/4.8/sstream" 3
  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:
# 422 "/usr/include/c++/4.8/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 440 "/usr/include/c++/4.8/sstream" 3
      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()
      { }
# 462 "/usr/include/c++/4.8/sstream" 3
      __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); }
    };
# 501 "/usr/include/c++/4.8/sstream" 3
  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:
# 536 "/usr/include/c++/4.8/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 552 "/usr/include/c++/4.8/sstream" 3
      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()
      { }
# 574 "/usr/include/c++/4.8/sstream" 3
      __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); }
    };


}

# 1 "/usr/include/c++/4.8/bits/sstream.tcc" 1 3
# 37 "/usr/include/c++/4.8/bits/sstream.tcc" 3
       
# 38 "/usr/include/c++/4.8/bits/sstream.tcc" 3

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)
 {
# 110 "/usr/include/c++/4.8/bits/sstream.tcc" 3
   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>;




}
# 601 "/usr/include/c++/4.8/sstream" 2 3
# 18 "/usr/include/boost/date_time/date_generators.hpp" 2 3 4




namespace boost {
namespace date_time {







  template<class date_type>
  class year_based_generator
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::year_type year_type;
    year_based_generator() {}
    virtual ~year_based_generator() {}
    virtual date_type get_date(year_type y) const = 0;

    virtual std::string to_string() const =0;
  };
# 55 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
 class partial_date : public year_based_generator<date_type>
 {
 public:
   typedef typename date_type::calendar_type calendar_type;
   typedef typename calendar_type::day_type day_type;
   typedef typename calendar_type::month_type month_type;
   typedef typename calendar_type::year_type year_type;
   typedef typename date_type::duration_type duration_type;
   typedef typename duration_type::duration_rep duration_rep;
   partial_date(day_type d, month_type m) :
     day_(d),
     month_(m)
   {}





   partial_date(duration_rep days) :
     day_(1),
     month_(1)
   {
     date_type d1(2000,1,1);
     if(days > 1) {
       if(days > 366)
       {
         days = 366;
       }
       days = days - 1;
       duration_type dd(days);
       d1 = d1 + dd;
     }
     day_ = d1.day();
     month_ = d1.month();
   }
# 101 "/usr/include/boost/date_time/date_generators.hpp" 3 4
   date_type get_date(year_type y) const
   {
     if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
       std::ostringstream ss;
       ss << "No Feb 29th in given year of " << y << ".";
       boost::throw_exception(std::invalid_argument(ss.str()));
     }
     return date_type(y, month_, day_);
   }
   date_type operator()(year_type y) const
   {
     return get_date(y);

   }
   bool operator==(const partial_date& rhs) const
   {
     return (month_ == rhs.month_) && (day_ == rhs.day_);
   }
   bool operator<(const partial_date& rhs) const
   {
     if (month_ < rhs.month_) return true;
     if (month_ > rhs.month_) return false;

     return (day_ < rhs.day_);
   }


   month_type month() const
   {
     return month_;
   }
   day_type day() const
   {
     return day_;
   }






   virtual std::string to_string() const
   {
     std::ostringstream ss;
     date_type d(2004, month_, day_);
     unsigned short c = d.day_of_year();
     c--;
     ss << c;
     return ss.str();
   }
 private:
   day_type day_;
   month_type month_;
 };



  const char* nth_as_str(int n);
# 177 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class nth_kday_of_month : public year_based_generator<date_type>
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename calendar_type::month_type month_type;
    typedef typename calendar_type::year_type year_type;
    typedef typename date_type::duration_type duration_type;
    enum week_num {first=1, second, third, fourth, fifth};
    nth_kday_of_month(week_num week_no,
                      day_of_week_type dow,
                      month_type m) :
      month_(m),
      wn_(week_no),
      dow_(dow)
    {}

    date_type get_date(year_type y) const
    {
      date_type d(y, month_, 1);
      duration_type one_day(1);
      duration_type one_week(7);
      while (dow_ != d.day_of_week()) {
        d = d + one_day;
      }
      int week = 1;
      while (week < wn_) {
        d = d + one_week;
        week++;
      }

      if(d.month() != month_) {
        d = d - one_week;
      }
      return d;
    }

    month_type month() const
    {
      return month_;
    }
    week_num nth_week() const
    {
      return wn_;
    }
    day_of_week_type day_of_week() const
    {
      return dow_;
    }
    const char* nth_week_as_str() const
    {
      return nth_as_str(wn_);
    }


    virtual std::string to_string() const
    {
     std::ostringstream ss;
     ss << 'M'
       << static_cast<int>(month_) << '.'
       << static_cast<int>(wn_) << '.'
       << static_cast<int>(dow_);
     return ss.str();
    }
  private:
    month_type month_;
    week_num wn_;
    day_of_week_type dow_;
  };





  template<class date_type>
  class first_kday_of_month : public year_based_generator<date_type>
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename calendar_type::month_type month_type;
    typedef typename calendar_type::year_type year_type;
    typedef typename date_type::duration_type duration_type;




    first_kday_of_month(day_of_week_type dow, month_type m) :
      month_(m),
      dow_(dow)
    {}

    date_type get_date(year_type year) const
    {
      date_type d(year, month_,1);
      duration_type one_day(1);
      while (dow_ != d.day_of_week()) {
        d = d + one_day;
      }
      return d;
    }

    month_type month() const
    {
      return month_;
    }
    day_of_week_type day_of_week() const
    {
      return dow_;
    }


    virtual std::string to_string() const
    {
     std::ostringstream ss;
     ss << 'M'
       << static_cast<int>(month_) << '.'
       << 1 << '.'
       << static_cast<int>(dow_);
     return ss.str();
    }
  private:
    month_type month_;
    day_of_week_type dow_;
  };
# 313 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class last_kday_of_month : public year_based_generator<date_type>
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename calendar_type::month_type month_type;
    typedef typename calendar_type::year_type year_type;
    typedef typename date_type::duration_type duration_type;




    last_kday_of_month(day_of_week_type dow, month_type m) :
      month_(m),
      dow_(dow)
    {}

    date_type get_date(year_type year) const
    {
      date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
      duration_type one_day(1);
      while (dow_ != d.day_of_week()) {
        d = d - one_day;
      }
      return d;
    }

    month_type month() const
    {
      return month_;
    }
    day_of_week_type day_of_week() const
    {
      return dow_;
    }


    virtual std::string to_string() const
    {
      std::ostringstream ss;
      ss << 'M'
         << static_cast<int>(month_) << '.'
         << 5 << '.'
         << static_cast<int>(dow_);
      return ss.str();
    }
  private:
    month_type month_;
    day_of_week_type dow_;
   };
# 375 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class first_kday_after
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename date_type::duration_type duration_type;
    first_kday_after(day_of_week_type dow) :
      dow_(dow)
    {}

    date_type get_date(date_type start_day) const
    {
      duration_type one_day(1);
      date_type d = start_day + one_day;
      while (dow_ != d.day_of_week()) {
        d = d + one_day;
      }
      return d;
    }

    day_of_week_type day_of_week() const
    {
      return dow_;
    }
  private:
    day_of_week_type dow_;
  };
# 413 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class first_kday_before
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename date_type::duration_type duration_type;
    first_kday_before(day_of_week_type dow) :
      dow_(dow)
    {}

    date_type get_date(date_type start_day) const
    {
      duration_type one_day(1);
      date_type d = start_day - one_day;
      while (dow_ != d.day_of_week()) {
        d = d - one_day;
      }
      return d;
    }

    day_of_week_type day_of_week() const
    {
      return dow_;
    }
  private:
    day_of_week_type dow_;
  };





  template<typename date_type, class weekday_type>
  inline
  typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
  {
    typedef typename date_type::duration_type duration_type;
    duration_type wks(0);
    duration_type dd(wd.as_number() - d.day_of_week().as_number());
    if(dd.is_negative()){
      wks = duration_type(7);
    }
    return dd + wks;
  }






  template<typename date_type, class weekday_type>
  inline
  typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
  {
    typedef typename date_type::duration_type duration_type;
    duration_type wks(0);
    duration_type dd(wd.as_number() - d.day_of_week().as_number());
    if(dd.days() > 0){
      wks = duration_type(7);
    }


    return (-dd + wks);
  }






  template<class date_type, class weekday_type>
  inline
  date_type next_weekday(const date_type& d, const weekday_type& wd)
  {
    return d + days_until_weekday(d, wd);
  }






  template<class date_type, class weekday_type>
  inline
  date_type previous_weekday(const date_type& d, const weekday_type& wd)
  {
    return d - days_before_weekday(d, wd);
  }

} }
# 26 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_clock_device.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/date_clock_device.hpp" 3 4
namespace boost {
namespace date_time {







  template<class date_type>
  class day_clock
  {
  public:
    typedef typename date_type::ymd_type ymd_type;

    static date_type local_day()
    {
      return date_type(local_day_ymd());
    }

    static typename date_type::ymd_type local_day_ymd()
    {
      ::std::tm result;
      ::std::tm* curr = get_local_time(result);
      return ymd_type(curr->tm_year + 1900,
                      curr->tm_mon + 1,
                      curr->tm_mday);
    }

    static typename date_type::ymd_type universal_day_ymd()
    {
      ::std::tm result;
      ::std::tm* curr = get_universal_time(result);
      return ymd_type(curr->tm_year + 1900,
                      curr->tm_mon + 1,
                      curr->tm_mday);
    }

    static date_type universal_day()
    {
      return date_type(universal_day_ymd());
    }

  private:
    static ::std::tm* get_local_time(std::tm& result)
    {
      ::std::time_t t;
      ::std::time(&t);
      return c_time::localtime(&t, &result);
    }
    static ::std::tm* get_universal_time(std::tm& result)
    {
      ::std::time_t t;
      ::std::time(&t);
      return c_time::gmtime(&t, &result);
    }

  };

} }
# 27 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_iterator.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
namespace boost {
namespace date_time {

  enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
# 32 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
  template<class date_type>
  class date_itr_base {



  public:
    typedef typename date_type::duration_type duration_type;
    typedef date_type value_type;
    typedef std::input_iterator_tag iterator_category;

    date_itr_base(date_type d) : current_(d) {}
    virtual ~date_itr_base() {}
    date_itr_base& operator++()
    {
      current_ = current_ + get_offset(current_);
      return *this;
    }
    date_itr_base& operator--()
    {
      current_ = current_ + get_neg_offset(current_);
      return *this;
    }
    virtual duration_type get_offset(const date_type& current) const=0;
    virtual duration_type get_neg_offset(const date_type& current) const=0;
    date_type operator*() {return current_;}
    date_type* operator->() {return &current_;}
    bool operator< (const date_type& d) {return current_ < d;}
    bool operator<= (const date_type& d) {return current_ <= d;}
    bool operator> (const date_type& d) {return current_ > d;}
    bool operator>= (const date_type& d) {return current_ >= d;}
    bool operator== (const date_type& d) {return current_ == d;}
    bool operator!= (const date_type& d) {return current_ != d;}
  private:
    date_type current_;
  };
# 76 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
  template<class offset_functor, class date_type>
  class date_itr : public date_itr_base<date_type> {
  public:
    typedef typename date_type::duration_type duration_type;
    date_itr(date_type d, int factor=1) :
      date_itr_base<date_type>(d),
      of_(factor)
    {}
  private:
    virtual duration_type get_offset(const date_type& current) const
    {
      return of_.get_offset(current);
    }
    virtual duration_type get_neg_offset(const date_type& current) const
    {
      return of_.get_neg_offset(current);
    }
    offset_functor of_;
  };



} }
# 28 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4


namespace boost {






namespace gregorian {



  typedef date_time::period<date, date_duration> date_period;






  typedef date_time::year_based_generator<date> year_based_generator;


  typedef date_time::partial_date<date> partial_date;

  typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
  typedef nth_kday_of_month nth_day_of_the_week_in_month;

  typedef date_time::first_kday_of_month<date> first_kday_of_month;
  typedef first_kday_of_month first_day_of_the_week_in_month;

  typedef date_time::last_kday_of_month<date> last_kday_of_month;
  typedef last_kday_of_month last_day_of_the_week_in_month;

  typedef date_time::first_kday_after<date> first_kday_after;
  typedef first_kday_after first_day_of_the_week_after;

  typedef date_time::first_kday_before<date> first_kday_before;
  typedef first_kday_before first_day_of_the_week_before;




  typedef date_time::day_clock<date> day_clock;




  typedef date_time::date_itr_base<date> date_iterator;




  typedef date_time::date_itr<date_time::day_functor<date>,
                              date> day_iterator;



  typedef date_time::date_itr<date_time::week_functor<date>,
                              date> week_iterator;



  typedef date_time::date_itr<date_time::month_functor<date>,
                              date> month_iterator;



  typedef date_time::date_itr<date_time::year_functor<date>,
                              date> year_iterator;


  using date_time::days_until_weekday;
  using date_time::days_before_weekday;
  using date_time::next_weekday;
  using date_time::previous_weekday;

} }
# 19 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4



namespace boost {
namespace posix_time {
# 40 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
  typedef date_time::time_resolution_traits<
    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
                                            1000000, 6 > time_res_traits;
# 57 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
  class time_duration :
    public date_time::time_duration<time_duration, time_res_traits>
  {
  public:
    typedef time_res_traits rep_type;
    typedef time_res_traits::day_type day_type;
    typedef time_res_traits::hour_type hour_type;
    typedef time_res_traits::min_type min_type;
    typedef time_res_traits::sec_type sec_type;
    typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
    typedef time_res_traits::tick_type tick_type;
    typedef time_res_traits::impl_type impl_type;
    time_duration(hour_type hour,
                  min_type min,
                  sec_type sec,
                  fractional_seconds_type fs=0) :
      date_time::time_duration<time_duration, time_res_traits>(hour,min,sec,fs)
    {}
    time_duration() :
      date_time::time_duration<time_duration, time_res_traits>(0,0,0)
    {}

    time_duration(boost::date_time::special_values sv) :
      date_time::time_duration<time_duration, time_res_traits>(sv)
    {}

    friend class date_time::time_duration<time_duration, time_res_traits>;
  protected:
    explicit time_duration(impl_type tick_count) :
      date_time::time_duration<time_duration, time_res_traits>(tick_count)
    {}
  };
# 154 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
  class millisec_posix_time_system_config
  {
   public:
    typedef boost::int64_t time_rep_type;

    typedef gregorian::date date_type;
    typedef gregorian::date_duration date_duration_type;
    typedef time_duration time_duration_type;
    typedef time_res_traits::tick_type int_type;
    typedef time_res_traits::impl_type impl_type;
    typedef time_res_traits resolution_traits;


    static const boost::int64_t tick_per_second = 1000000;

  };



} }
# 14 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_system_split.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/time_system_split.hpp" 3 4
namespace boost {
namespace date_time {





  template<typename config>

  class split_timedate_system
  {
   public:
    typedef typename config::time_rep_type time_rep_type;
    typedef typename config::date_type date_type;
    typedef typename config::time_duration_type time_duration_type;
    typedef typename config::date_duration_type date_duration_type;
    typedef typename config::int_type int_type;
    typedef typename config::resolution_traits resolution_traits;





   private:
     static const int_type ticks_per_day = 86400LL * config::tick_per_second;
   public:



    typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;



    static time_rep_type get_time_rep(special_values sv)
    {
      switch (sv) {
      case not_a_date_time:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));
      case pos_infin:
        return time_rep_type(date_type(pos_infin),
                             time_duration_type(pos_infin));
      case neg_infin:
        return time_rep_type(date_type(neg_infin),
                             time_duration_type(neg_infin));
      case max_date_time: {
        time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
        return time_rep_type(date_type(max_date_time), td);
      }
      case min_date_time:
        return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));

      default:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));

      }

    }

    static time_rep_type get_time_rep(const date_type& day,
                                      const time_duration_type& tod,
                                      date_time::dst_flags = not_dst)
    {
      if(day.is_special() || tod.is_special()) {
        if(day.is_not_a_date() || tod.is_not_a_date_time()) {
          return time_rep_type(date_type(not_a_date_time),
                               time_duration_type(not_a_date_time));
        }
        else if(day.is_pos_infinity()) {
          if(tod.is_neg_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(day, time_duration_type(pos_infin));
          }
        }
        else if(day.is_neg_infinity()) {
          if(tod.is_pos_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(day, time_duration_type(neg_infin));
          }
        }
        else if(tod.is_pos_infinity()) {
          if(day.is_neg_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(date_type(pos_infin), tod);
          }
        }
        else if(tod.is_neg_infinity()) {
          if(day.is_pos_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(date_type(neg_infin), tod);
          }
        }
      }
      return time_rep_type(day, tod);
    }
    static date_type get_date(const time_rep_type& val)
    {
      return date_type(val.day);
    }
    static time_duration_type get_time_of_day(const time_rep_type& val)
    {
      return time_duration_type(val.time_of_day);
    }
    static std::string zone_name(const time_rep_type&)
    {
      return std::string();
    }
    static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return ((lhs.day == rhs.day) && (lhs.time_of_day == rhs.time_of_day));
    }
    static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      if (lhs.day < rhs.day) return true;
      if (lhs.day > rhs.day) return false;
      return (lhs.time_of_day < rhs.time_of_day);
    }
    static time_rep_type add_days(const time_rep_type& base,
                                  const date_duration_type& dd)
    {
      return time_rep_type(base.day+dd, base.time_of_day);
    }
    static time_rep_type subtract_days(const time_rep_type& base,
                                       const date_duration_type& dd)
    {
      return split_timedate_system::get_time_rep(base.day-dd, base.time_of_day);
    }
    static time_rep_type subtract_time_duration(const time_rep_type& base,
                                                const time_duration_type& td)
    {
      if(base.day.is_special() || td.is_special())
      {
        return split_timedate_system::get_time_rep(base.day, -td);
      }
      if (td.is_negative()) {
        time_duration_type td1 = td.invert_sign();
        return add_time_duration(base,td1);
      }

      wrap_int_type day_offset(base.time_of_day.ticks());
      date_duration_type day_overflow(static_cast<typename date_duration_type::duration_rep_type>(day_offset.subtract(td.ticks())));

      return time_rep_type(base.day-day_overflow,
                           time_duration_type(0,0,0,day_offset.as_int()));
    }
    static time_rep_type add_time_duration(const time_rep_type& base,
                                           time_duration_type td)
    {
      if(base.day.is_special() || td.is_special()) {
        return split_timedate_system::get_time_rep(base.day, td);
      }
      if (td.is_negative()) {
        time_duration_type td1 = td.invert_sign();
        return subtract_time_duration(base,td1);
      }

      wrap_int_type day_offset(base.time_of_day.ticks());
      date_duration_type day_overflow(static_cast< typename date_duration_type::duration_rep_type >(day_offset.add(td.ticks())));

      return time_rep_type(base.day+day_overflow,
                           time_duration_type(0,0,0,day_offset.as_int()));
    }
    static time_duration_type subtract_times(const time_rep_type& lhs,
                                             const time_rep_type& rhs)
    {
      date_duration_type dd = lhs.day - rhs.day;
      time_duration_type td(dd.days()*24,0,0);
      time_duration_type td2 = lhs.time_of_day - rhs.time_of_day;
      return td+td2;

    }

  };

} }
# 15 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_system_counted.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
namespace boost {
namespace date_time {


  template<class config>
  struct counted_time_rep
  {
    typedef typename config::int_type int_type;
    typedef typename config::date_type date_type;
    typedef typename config::impl_type impl_type;
    typedef typename date_type::duration_type date_duration_type;
    typedef typename date_type::calendar_type calendar_type;
    typedef typename date_type::ymd_type ymd_type;
    typedef typename config::time_duration_type time_duration_type;
    typedef typename config::resolution_traits resolution_traits;

    counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
      : time_count_(1)
    {
      if(d.is_infinity() || d.is_not_a_date() || time_of_day.is_special()) {
        time_count_ = time_of_day.get_rep() + d.day_count();

      }
      else {
        time_count_ = (d.day_number() * frac_sec_per_day()) + time_of_day.ticks();
      }
    }
    explicit counted_time_rep(int_type count) :
      time_count_(count)
    {}
    explicit counted_time_rep(impl_type count) :
      time_count_(count)
    {}
    date_type date() const
    {
      if(time_count_.is_special()) {
        return date_type(time_count_.as_special());
      }
      else {
        typename calendar_type::date_int_type dc = day_count();

        ymd_type ymd = calendar_type::from_day_number(dc);
        return date_type(ymd);
      }
    }

    unsigned long day_count() const
    {
# 78 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
      return static_cast<unsigned long>(resolution_traits::as_number(time_count_) / frac_sec_per_day());
    }
    int_type time_count() const
    {
      return resolution_traits::as_number(time_count_);
    }
    int_type tod() const
    {
      return resolution_traits::as_number(time_count_) % frac_sec_per_day();
    }
    static int_type frac_sec_per_day()
    {
      int_type seconds_per_day = 60*60*24;
      int_type fractional_sec_per_sec(resolution_traits::res_adjust());
      return seconds_per_day*fractional_sec_per_sec;
    }
    bool is_pos_infinity()const
    {
      return impl_type::is_pos_inf(time_count_.as_number());
    }
    bool is_neg_infinity()const
    {
      return impl_type::is_neg_inf(time_count_.as_number());
    }
    bool is_not_a_date_time()const
    {
      return impl_type::is_not_a_number(time_count_.as_number());
    }
    bool is_special()const
    {
      return time_count_.is_special();
    }
    impl_type get_rep()const
    {
      return time_count_;
    }
  private:
    impl_type time_count_;
  };


  template<class time_rep>
  class counted_time_system
  {
   public:
    typedef time_rep time_rep_type;
    typedef typename time_rep_type::impl_type impl_type;
    typedef typename time_rep_type::time_duration_type time_duration_type;
    typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
    typedef typename time_rep_type::date_type date_type;
    typedef typename time_rep_type::date_duration_type date_duration_type;


    template<class T> static void unused_var(const T&) {}

    static time_rep_type get_time_rep(const date_type& day,
                                      const time_duration_type& tod,
                                      date_time::dst_flags dst=not_dst)
    {
      unused_var(dst);
      return time_rep_type(day, tod);
    }

    static time_rep_type get_time_rep(special_values sv)
    {
      switch (sv) {
      case not_a_date_time:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));
      case pos_infin:
        return time_rep_type(date_type(pos_infin),
                             time_duration_type(pos_infin));
      case neg_infin:
        return time_rep_type(date_type(neg_infin),
                             time_duration_type(neg_infin));
      case max_date_time: {
        time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
        return time_rep_type(date_type(max_date_time), td);
      }
      case min_date_time:
        return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));

      default:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));

      }

    }

    static date_type get_date(const time_rep_type& val)
    {
      return val.date();
    }
    static time_duration_type get_time_of_day(const time_rep_type& val)
    {
      if(val.is_special()) {
        return time_duration_type(val.get_rep().as_special());
      }
      else{
        return time_duration_type(0,0,0,val.tod());
      }
    }
    static std::string zone_name(const time_rep_type&)
    {
      return "";
    }
    static bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return (lhs.time_count() == rhs.time_count());
    }
    static bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return (lhs.time_count() < rhs.time_count());
    }
    static time_rep_type add_days(const time_rep_type& base,
                                  const date_duration_type& dd)
    {
      if(base.is_special() || dd.is_special()) {
        return(time_rep_type(base.get_rep() + dd.get_rep()));
      }
      else {
        return time_rep_type(base.time_count() + (dd.days() * time_rep_type::frac_sec_per_day()));
      }
    }
    static time_rep_type subtract_days(const time_rep_type& base,
                                       const date_duration_type& dd)
    {
      if(base.is_special() || dd.is_special()) {
        return(time_rep_type(base.get_rep() - dd.get_rep()));
      }
      else{
        return time_rep_type(base.time_count() - (dd.days() * time_rep_type::frac_sec_per_day()));
      }
    }
    static time_rep_type subtract_time_duration(const time_rep_type& base,
                                                const time_duration_type& td)
    {
      if(base.is_special() || td.is_special()) {
        return(time_rep_type(base.get_rep() - td.get_rep()));
      }
      else {
        return time_rep_type(base.time_count() - td.ticks());
      }
    }
    static time_rep_type add_time_duration(const time_rep_type& base,
                                           time_duration_type td)
    {
      if(base.is_special() || td.is_special()) {
        return(time_rep_type(base.get_rep() + td.get_rep()));
      }
      else {
        return time_rep_type(base.time_count() + td.ticks());
      }
    }
    static time_duration_type subtract_times(const time_rep_type& lhs,
                                             const time_rep_type& rhs)
    {
      if(lhs.is_special() || rhs.is_special()) {
        return(time_duration_type(
          impl_type::to_special((lhs.get_rep() - rhs.get_rep()).as_number())));
      }
      else {
        fractional_seconds_type fs = lhs.time_count() - rhs.time_count();
        return time_duration_type(0,0,0,fs);
      }
    }

  };


} }
# 16 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4



namespace boost {
namespace posix_time {
# 32 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
  typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
  typedef date_time::counted_time_system<int64_time_rep> posix_time_system;



} }
# 13 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time.hpp" 1 3 4
# 21 "/usr/include/boost/date_time/time.hpp" 3 4
namespace boost {
namespace date_time {
# 45 "/usr/include/boost/date_time/time.hpp" 3 4
  template <class T, class time_system>
  class base_time : private
      boost::less_than_comparable<T
    , boost::equality_comparable<T
      > >
  {
  public:
    typedef T time_type;
    typedef typename time_system::time_rep_type time_rep_type;
    typedef typename time_system::date_type date_type;
    typedef typename time_system::date_duration_type date_duration_type;
    typedef typename time_system::time_duration_type time_duration_type;


    base_time(const date_type& day,
              const time_duration_type& td,
              dst_flags dst=not_dst) :
      time_(time_system::get_time_rep(day, td, dst))
    {}
    base_time(special_values sv) :
      time_(time_system::get_time_rep(sv))
    {}
    base_time(const time_rep_type& rhs) :
      time_(rhs)
    {}
    date_type date() const
    {
      return time_system::get_date(time_);
    }
    time_duration_type time_of_day() const
    {
      return time_system::get_time_of_day(time_);
    }



    std::string zone_name(bool =false) const
    {
      return time_system::zone_name(time_);
    }



    std::string zone_abbrev(bool =false) const
    {
      return time_system::zone_name(time_);
    }

    std::string zone_as_posix_string() const
    {
      return std::string();
    }


    bool is_not_a_date_time() const
    {
      return time_.is_not_a_date_time();
    }

    bool is_infinity() const
    {
      return (is_pos_infinity() || is_neg_infinity());
    }

    bool is_pos_infinity() const
    {
      return time_.is_pos_infinity();
    }

    bool is_neg_infinity() const
    {
      return time_.is_neg_infinity();
    }

    bool is_special() const
    {
      return(is_not_a_date_time() || is_infinity());
    }

    bool operator==(const time_type& rhs) const
    {
      return time_system::is_equal(time_,rhs.time_);
    }

    bool operator<(const time_type& rhs) const
    {
      return time_system::is_less(time_,rhs.time_);
    }

    time_duration_type operator-(const time_type& rhs) const
    {
      return time_system::subtract_times(time_, rhs.time_);
    }

    time_type operator+(const date_duration_type& dd) const
    {
      return time_system::add_days(time_, dd);
    }
    time_type operator+=(const date_duration_type& dd)
    {
      time_ = (time_system::get_time_rep(date() + dd, time_of_day()));
      return time_type(time_);
    }

    time_type operator-(const date_duration_type& dd) const
    {
      return time_system::subtract_days(time_, dd);
    }
    time_type operator-=(const date_duration_type& dd)
    {
      time_ = (time_system::get_time_rep(date() - dd, time_of_day()));
      return time_type(time_);
    }

    time_type operator+(const time_duration_type& td) const
    {
      return time_type(time_system::add_time_duration(time_, td));
    }
    time_type operator+=(const time_duration_type& td)
    {
      time_ = (time_system::get_time_rep(date(), time_of_day() + td));
      return time_type(time_);
    }

    time_type operator-(const time_duration_type& rhs) const
    {
      return time_system::subtract_time_duration(time_, rhs);
    }
    time_type operator-=(const time_duration_type& td)
    {
      time_ = (time_system::get_time_rep(date(), time_of_day() - td));
      return time_type(time_);
    }

  protected:
    time_rep_type time_;
  };





} }
# 14 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4

namespace boost {

namespace posix_time {


  using date_time::special_values;
  using date_time::not_special;
  using date_time::neg_infin;
  using date_time::pos_infin;
  using date_time::not_a_date_time;
  using date_time::max_date_time;
  using date_time::min_date_time;




  class ptime : public date_time::base_time<ptime, posix_time_system>
  {
  public:
    typedef posix_time_system time_system_type;
    typedef time_system_type::time_rep_type time_rep_type;
    typedef time_system_type::time_duration_type time_duration_type;
    typedef ptime time_type;

    ptime(gregorian::date d,time_duration_type td) : date_time::base_time<time_type,time_system_type>(d,td)
    {}

    explicit ptime(gregorian::date d) : date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
    {}

    ptime(const time_rep_type& rhs):
      date_time::base_time<time_type,time_system_type>(rhs)
    {}

    ptime(const special_values sv) : date_time::base_time<time_type,time_system_type>(sv)
    {}


    ptime() : date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time), time_duration_type(not_a_date_time))
    {}


  };



} }
# 13 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
namespace boost {
namespace posix_time {
# 29 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
  inline
  ptime
  operator+(const ptime& t, const boost::gregorian::months& m)
  {
    return t + m.get_offset(t.date());
  }




  inline
  ptime
  operator+=(ptime& t, const boost::gregorian::months& m)
  {

    return t += m.get_offset(t.date());
  }




  inline
  ptime
  operator-(const ptime& t, const boost::gregorian::months& m)
  {

    return t + m.get_neg_offset(t.date());
  }




  inline
  ptime
  operator-=(ptime& t, const boost::gregorian::months& m)
  {
    return t += m.get_neg_offset(t.date());
  }






  inline
  ptime
  operator+(const ptime& t, const boost::gregorian::years& y)
  {
    return t + y.get_offset(t.date());
  }




  inline
  ptime
  operator+=(ptime& t, const boost::gregorian::years& y)
  {
    return t += y.get_offset(t.date());
  }




  inline
  ptime
  operator-(const ptime& t, const boost::gregorian::years& y)
  {

    return t + y.get_neg_offset(t.date());
  }




  inline
  ptime
  operator-=(ptime& t, const boost::gregorian::years& y)
  {

    return t += y.get_neg_offset(t.date());
  }

}}
# 15 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
namespace boost {
namespace posix_time {




  class hours : public time_duration
  {
  public:
    explicit hours(long h) :
      time_duration(h,0,0)
    {}
  };




  class minutes : public time_duration
  {
  public:
    explicit minutes(long m) :
      time_duration(0,m,0)
    {}
  };




  class seconds : public time_duration
  {
  public:
    explicit seconds(long s) :
      time_duration(0,0,s)
    {}
  };





  typedef date_time::subsecond_duration<time_duration,1000> millisec;
  typedef date_time::subsecond_duration<time_duration,1000> milliseconds;




  typedef date_time::subsecond_duration<time_duration,1000000> microsec;
  typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
# 78 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
} }
# 17 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/time_period.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/posix_time/time_period.hpp" 3 4
namespace boost {
namespace posix_time {




  typedef date_time::period<ptime, time_duration> time_period;


} }
# 19 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_iterator.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/time_iterator.hpp" 3 4
namespace boost {
namespace date_time {



  template<class time_type>
  class time_itr {
  public:
    typedef typename time_type::time_duration_type time_duration_type;
    time_itr(time_type t, time_duration_type d) : current_(t), offset_(d) {}
    time_itr& operator++()
    {
      current_ = current_ + offset_;
      return *this;
    }
    time_itr& operator--()
    {
      current_ = current_ - offset_;
      return *this;
    }
    time_type operator*() {return current_;}
    time_type* operator->() {return &current_;}
    bool operator< (const time_type& t) {return current_ < t;}
    bool operator<= (const time_type& t) {return current_ <= t;}
    bool operator!= (const time_type& t) {return current_ != t;}
    bool operator== (const time_type& t) {return current_ == t;}
    bool operator> (const time_type& t) {return current_ > t;}
    bool operator>= (const time_type& t) {return current_ >= t;}

  private:
    time_type current_;
    time_duration_type offset_;
  };



} }
# 20 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/dst_rules.hpp" 1 3 4
# 21 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
namespace boost {
  namespace date_time {

    enum time_is_dst_result {is_not_in_dst, is_in_dst,
                             ambiguous, invalid_time_label};



    template<class date_type_,
             class time_duration_type_>
    class dst_calculator
    {
    public:
      typedef time_duration_type_ time_duration_type;
      typedef date_type_ date_type;
# 47 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      process_local_dst_start_day(const time_duration_type& time_of_day,
                                  unsigned int dst_start_offset_minutes,
                                  long dst_length_minutes)
      {

        if (time_of_day < time_duration_type(0,dst_start_offset_minutes,0)) {
          return is_not_in_dst;
        }
        long offset = dst_start_offset_minutes + dst_length_minutes;
        if (time_of_day >= time_duration_type(0,offset,0)) {
          return is_in_dst;
        }
        return invalid_time_label;
      }
# 72 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      process_local_dst_end_day(const time_duration_type& time_of_day,
                                unsigned int dst_end_offset_minutes,
                                long dst_length_minutes)
      {

        int offset = dst_end_offset_minutes-dst_length_minutes;
        if (time_of_day < time_duration_type(0,offset,0)) {
          return is_in_dst;
        }
        if (time_of_day >= time_duration_type(0,dst_end_offset_minutes,0)) {
          return is_not_in_dst;
        }
        return ambiguous;
      }
# 100 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      local_is_dst(const date_type& current_day,
                   const time_duration_type& time_of_day,
                   const date_type& dst_start_day,
                   const time_duration_type& dst_start_offset,
                   const date_type& dst_end_day,
                   const time_duration_type& dst_end_offset,
                   const time_duration_type& dst_length_minutes)
      {
        unsigned int start_minutes =
          dst_start_offset.hours() * 60 + dst_start_offset.minutes();
        unsigned int end_minutes =
          dst_end_offset.hours() * 60 + dst_end_offset.minutes();
        long length_minutes =
          dst_length_minutes.hours() * 60 + dst_length_minutes.minutes();

        return local_is_dst(current_day, time_of_day,
                            dst_start_day, start_minutes,
                            dst_end_day, end_minutes,
                            length_minutes);
      }
# 136 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      local_is_dst(const date_type& current_day,
                   const time_duration_type& time_of_day,
                   const date_type& dst_start_day,
                   unsigned int dst_start_offset_minutes,
                   const date_type& dst_end_day,
                   unsigned int dst_end_offset_minutes,
                   long dst_length_minutes)
      {

        if (dst_start_day < dst_end_day) {
          if ((current_day > dst_start_day) && (current_day < dst_end_day)) {
            return is_in_dst;
          }
          if ((current_day < dst_start_day) || (current_day > dst_end_day)) {
            return is_not_in_dst;
          }
        }
        else {
          if ((current_day < dst_start_day) && (current_day > dst_end_day)) {
            return is_not_in_dst;
          }
          if ((current_day > dst_start_day) || (current_day < dst_end_day)) {
            return is_in_dst;
          }
        }

        if (current_day == dst_start_day) {
          return process_local_dst_start_day(time_of_day,
                                             dst_start_offset_minutes,
                                             dst_length_minutes);
        }

        if (current_day == dst_end_day) {
          return process_local_dst_end_day(time_of_day,
                                           dst_end_offset_minutes,
                                           dst_length_minutes);
        }

        return invalid_time_label;
      }

    };
# 208 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
    template<class date_type,
             class time_duration_type,
             class dst_traits>
    class dst_calc_engine
    {
    public:
      typedef typename date_type::year_type year_type;
      typedef typename date_type::calendar_type calendar_type;
      typedef dst_calculator<date_type, time_duration_type> dstcalc;






      static time_is_dst_result local_is_dst(const date_type& d,
                                             const time_duration_type& td)
      {

        year_type y = d.year();
        date_type dst_start = local_dst_start_day(y);
        date_type dst_end = local_dst_end_day(y);
        return dstcalc::local_is_dst(d,td,
                                     dst_start,
                                     dst_traits::dst_start_offset_minutes(),
                                     dst_end,
                                     dst_traits::dst_end_offset_minutes(),
                                     dst_traits::dst_shift_length_minutes());

      }

      static bool is_dst_boundary_day(date_type d)
      {
        year_type y = d.year();
        return ((d == local_dst_start_day(y)) ||
                (d == local_dst_end_day(y)));
      }


      static time_duration_type dst_offset()
      {
        return time_duration_type(0,dst_traits::dst_shift_length_minutes(),0);
      }

      static date_type local_dst_start_day(year_type year)
      {
        return dst_traits::local_dst_start_day(year);
      }

      static date_type local_dst_end_day(year_type year)
      {
        return dst_traits::local_dst_end_day(year);
      }


    };






    template<class date_type_,
             class time_duration_type_,
             unsigned int dst_start_offset_minutes=120,
             short dst_length_minutes=60>
    class us_dst_rules
    {
    public:
      typedef time_duration_type_ time_duration_type;
      typedef date_type_ date_type;
      typedef typename date_type::year_type year_type;
      typedef typename date_type::calendar_type calendar_type;
      typedef date_time::last_kday_of_month<date_type> lkday;
      typedef date_time::first_kday_of_month<date_type> fkday;
      typedef date_time::nth_kday_of_month<date_type> nkday;
      typedef dst_calculator<date_type, time_duration_type> dstcalc;






      static time_is_dst_result local_is_dst(const date_type& d,
                                             const time_duration_type& td)
      {

        year_type y = d.year();
        date_type dst_start = local_dst_start_day(y);
        date_type dst_end = local_dst_end_day(y);
        return dstcalc::local_is_dst(d,td,
                                     dst_start,dst_start_offset_minutes,
                                     dst_end, dst_start_offset_minutes,
                                     dst_length_minutes);

      }


      static bool is_dst_boundary_day(date_type d)
      {
        year_type y = d.year();
        return ((d == local_dst_start_day(y)) ||
                (d == local_dst_end_day(y)));
      }

      static date_type local_dst_start_day(year_type year)
      {
        if (year >= year_type(2007)) {

          nkday ssim(nkday::second, Sunday, gregorian::Mar);
          return ssim.get_date(year);
        } else {

          fkday fsia(Sunday, gregorian::Apr);
          return fsia.get_date(year);
        }
      }

      static date_type local_dst_end_day(year_type year)
      {
        if (year >= year_type(2007)) {

          fkday fsin(Sunday, gregorian::Nov);
          return fsin.get_date(year);
        } else {

          lkday lsio(Sunday, gregorian::Oct);
          return lsio.get_date(year);
        }
      }

      static time_duration_type dst_offset()
      {
        return time_duration_type(0,dst_length_minutes,0);
      }

     private:


    };


    template<class date_type_, class time_duration_type_>
    class null_dst_rules
    {
    public:
      typedef time_duration_type_ time_duration_type;
      typedef date_type_ date_type;





      static time_is_dst_result local_is_dst(const date_type&,
                                             const time_duration_type&)
      {
        return is_not_in_dst;
      }


      static time_is_dst_result utc_is_dst(const date_type&,
                                           const time_duration_type&)
      {
        return is_not_in_dst;
      }

      static bool is_dst_boundary_day(date_type )
      {
        return false;
      }

      static time_duration_type dst_offset()
      {
        return time_duration_type(0,0,0);
      }

    };


  } }
# 21 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

namespace boost {


namespace posix_time {




  typedef date_time::time_itr<ptime> time_iterator;



  typedef date_time::second_clock<ptime> second_clock;





  typedef date_time::microsec_clock<ptime> microsec_clock;



  typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;

  typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;


} }
# 12 "/usr/include/boost/thread/thread_time.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 14 "/usr/include/boost/thread/thread_time.hpp" 2 3 4

namespace boost
{
    typedef boost::posix_time::ptime system_time;

    inline system_time get_system_time()
    {

        return boost::date_time::microsec_clock<system_time>::universal_time();



    }

    namespace detail
    {
        inline system_time get_system_time_sentinel()
        {
            return system_time(boost::posix_time::pos_infin);
        }

        inline unsigned long get_milliseconds_until(system_time const& target_time)
        {
            if(target_time.is_pos_infinity())
            {
                return ~(unsigned long)0;
            }
            system_time const now=get_system_time();
            if(target_time<=now)
            {
                return 0;
            }
            return static_cast<unsigned long>((target_time-now).total_milliseconds()+1);
        }

    }

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 54 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
# 12 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/conversion.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/conversion.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3


# 1 "/usr/include/string.h" 1 3 4
# 27 "/usr/include/string.h" 3 4
extern "C" {




# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 33 "/usr/include/string.h" 2 3 4









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__)) void *
memchr (void *__s, int __c, size_t __n) throw ()
{
  return __builtin_memchr (__s, __c, __n);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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)));

# 162 "/usr/include/string.h" 3 4
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)));
# 207 "/usr/include/string.h" 3 4



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__)) char *
strchr (char *__s, int __c) throw ()
{
  return __builtin_strchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
strrchr (char *__s, int __c) throw ()
{
  return __builtin_strrchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
strpbrk (char *__s, const char *__accept) throw ()
{
  return __builtin_strpbrk (__s, __accept);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
strstr (char *__haystack, const char *__needle) throw ()
{
  return __builtin_strstr (__haystack, __needle);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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)));
# 378 "/usr/include/string.h" 3 4
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 ();

# 434 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));





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__)) char *
index (char *__s, int __c) throw ()
{
  return __builtin_index (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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__)) char *
rindex (char *__s, int __c) throw ()
{
  return __builtin_rindex (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) 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)));
# 638 "/usr/include/string.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/string3.h" 1 3 4
# 22 "/usr/include/i386-linux-gnu/bits/string3.h" 3 4
extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
                                                                                                   ;
# 47 "/usr/include/i386-linux-gnu/bits/string3.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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));
}
# 75 "/usr/include/i386-linux-gnu/bits/string3.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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));
}
# 639 "/usr/include/string.h" 2 3 4



}
# 43 "/usr/include/c++/4.8/cstring" 2 3
# 71 "/usr/include/c++/4.8/cstring" 3
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;
# 120 "/usr/include/c++/4.8/cstring" 3

}
# 13 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4





# 1 "/usr/include/boost/date_time/gregorian/conversion.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/conversion.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 13 "/usr/include/boost/date_time/gregorian/conversion.hpp" 2 3 4







namespace boost {

namespace gregorian {


  inline
  std::tm to_tm(const date& d)
  {
    if (d.is_special())
    {
        std::string s = "tm unable to handle ";
        switch (d.as_special())
        {
        case date_time::not_a_date_time:
            s += "not-a-date-time value"; break;
        case date_time::neg_infin:
            s += "-infinity date value"; break;
        case date_time::pos_infin:
            s += "+infinity date value"; break;
        default:
            s += "a special date value"; break;
        }
        boost::throw_exception(std::out_of_range(s));
    }

    std::tm datetm;
    std::memset(&datetm, 0, sizeof(datetm));
    boost::gregorian::date::ymd_type ymd = d.year_month_day();
    datetm.tm_year = ymd.year - 1900;
    datetm.tm_mon = ymd.month - 1;
    datetm.tm_mday = ymd.day;
    datetm.tm_wday = d.day_of_week();
    datetm.tm_yday = d.day_of_year() - 1;
    datetm.tm_isdst = -1;
    return datetm;
  }


  inline
  date date_from_tm(const std::tm& datetm)
  {
    return date(static_cast<unsigned short>(datetm.tm_year+1900),
                static_cast<unsigned short>(datetm.tm_mon+1),
                static_cast<unsigned short>(datetm.tm_mday));
  }

} }
# 19 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4

namespace boost {

namespace posix_time {



  inline
  ptime from_time_t(std::time_t t)
  {
    ptime start(gregorian::date(1970,1,1));
    return start + seconds(static_cast<long>(t));
  }


  inline
  std::tm to_tm(const boost::posix_time::ptime& t) {
    std::tm timetm = boost::gregorian::to_tm(t.date());
    boost::posix_time::time_duration td = t.time_of_day();
    timetm.tm_hour = td.hours();
    timetm.tm_min = td.minutes();
    timetm.tm_sec = td.seconds();
    timetm.tm_isdst = -1;
    return timetm;
  }

  inline
  std::tm to_tm(const boost::posix_time::time_duration& td) {
    std::tm timetm;
    std::memset(&timetm, 0, sizeof(timetm));
    timetm.tm_hour = date_time::absolute_value(td.hours());
    timetm.tm_min = date_time::absolute_value(td.minutes());
    timetm.tm_sec = date_time::absolute_value(td.seconds());
    timetm.tm_isdst = -1;
    return timetm;
  }


  inline
  ptime ptime_from_tm(const std::tm& timetm) {
    boost::gregorian::date d = boost::gregorian::date_from_tm(timetm);
    return ptime(d, time_duration(timetm.tm_hour, timetm.tm_min, timetm.tm_sec));
  }
# 88 "/usr/include/boost/date_time/posix_time/conversion.hpp" 3 4
} }
# 14 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4






# 1 "/usr/include/boost/chrono/duration.hpp" 1 3 4
# 33 "/usr/include/boost/chrono/duration.hpp" 3 4
# 1 "/usr/include/boost/chrono/config.hpp" 1 3 4
# 214 "/usr/include/boost/chrono/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 215 "/usr/include/boost/chrono/config.hpp" 2 3 4
# 34 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/detail/static_assert.hpp" 1 3 4
# 35 "/usr/include/boost/chrono/duration.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 34 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 168 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/posix1_lim.h" 1 3 4
# 160 "/usr/include/i386-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/local_lim.h" 1 3 4
# 38 "/usr/include/i386-linux-gnu/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/i386-linux-gnu/bits/local_lim.h" 2 3 4
# 161 "/usr/include/i386-linux-gnu/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/i386-linux-gnu/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/i386-linux-gnu/bits/xopen_lim.h" 1 3 4
# 33 "/usr/include/i386-linux-gnu/bits/xopen_lim.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/stdio_lim.h" 1 3 4
# 34 "/usr/include/i386-linux-gnu/bits/xopen_lim.h" 2 3 4
# 153 "/usr/include/limits.h" 2 3 4
# 169 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 2 3 4
# 8 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 2 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 37 "/usr/include/boost/chrono/duration.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/logical.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/logical.hpp" 3 4
# 1 "/usr/include/boost/mpl/or.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/or.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/or.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
    : T::type
{
};
}}}
# 24 "/usr/include/boost/mpl/or.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/or.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 16 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/compiler.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/stringize.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 3 4
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> { }; }





}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/or.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/logical.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/and.hpp" 1 3 4
# 42 "/usr/include/boost/mpl/and.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 3 4
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> { }; }





}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/and.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/logical.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/not.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/not.hpp" 3 4
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> { }; }

}}
# 20 "/usr/include/boost/mpl/logical.hpp" 2 3 4
# 41 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/ratio.hpp" 1 3 4
# 35 "/usr/include/boost/ratio/ratio.hpp" 3 4
# 1 "/usr/include/boost/ratio/config.hpp" 1 3 4
# 13 "/usr/include/boost/ratio/config.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/ratio/config.hpp" 2 3 4
# 36 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 1 3 4
# 32 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct abs_impl;

template< typename T > struct abs_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct abs
    : abs_impl<
          typename abs_tag<N>::type
        >::template apply<N>::type
{
   
};

template<> struct abs< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : abs< T1 > { }; }; template< typename Tag > struct lambda< abs< na > , Tag , int_<-1> > { typedef false_ is_le; typedef abs< na > result_; typedef abs< na > type; }; namespace aux { template< typename T1 > struct template_arity< abs< T1 > > : int_<1> { }; template<> struct template_arity< abs< na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    >
struct abs_c
    : abs<integral_c<T,n1> >
{
};
# 73 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 3 4
template<>
struct abs_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, ((N::value < 0) ? (-N::value) : N::value ) >

    {
    };
};

}}
# 37 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 1 3 4
# 32 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct sign_impl;

template< typename T > struct sign_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct sign
    : sign_impl<
          typename sign_tag<N>::type
        >::template apply<N>::type
{
   
};

template<> struct sign< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sign< T1 > { }; }; template< typename Tag > struct lambda< sign< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sign< na > result_; typedef sign< na > type; }; namespace aux { template< typename T1 > struct template_arity< sign< T1 > > : int_<1> { }; template<> struct template_arity< sign< na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    >
struct sign_c
    : sign<integral_c<T,n1> >
{
};
# 73 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 3 4
template<>
struct sign_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (N::value == 0 ? 0 : (N::value < 0 ? -1 : 1)) >

    {
    };
};

}}
# 38 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 1 3 4
# 17 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/largest_int.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/largest_int.hpp" 3 4
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
        >
{






};

}}}
# 18 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/config/dependent_nttp.hpp" 1 3 4
# 24 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 25 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
# 36 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag1, typename Tag2 > struct gcd_impl;

template< typename T > struct gcd_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct gcd
    : gcd_impl<
          typename gcd_tag<N1>::type
        , typename gcd_tag<N2>::type
        >::template apply<N1, N2>::type
{
   
};

template<> struct gcd< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : gcd< T1 , T2 > { }; }; template< typename Tag > struct lambda< gcd< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef gcd< na , na > result_; typedef gcd< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< gcd< T1 , T2 > > : int_<2> { }; template<> struct template_arity< gcd< na , na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    , T n2
    >
struct gcd_c
    : gcd<integral_c<T,n1>,integral_c<T,n2> >
{
};

namespace aux {






  template< typename T1, boost::intmax_t n1, bool n1_is_0
                  , typename T2, boost::intmax_t n2, bool n2_is_0 >
      struct gcd_aux
          : gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
      struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
      struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
      {};
# 110 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
}

template<>
struct gcd_impl<integral_c_tag, integral_c_tag>
{
    template< typename N1, typename N2 > struct apply
        : abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
                        typename N2::value_type, N2::value, N2::value==0 > >
    {
    };
};

}}
# 39 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 1 3 4
# 24 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 25 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 2 3 4
# 36 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag1, typename Tag2 > struct lcm_impl;

template< typename T > struct lcm_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct lcm
    : lcm_impl<
          typename lcm_tag<N1>::type
        , typename lcm_tag<N2>::type
        >::template apply<N1, N2>::type
{
   
};

template<> struct lcm< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lcm< T1 , T2 > { }; }; template< typename Tag > struct lambda< lcm< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lcm< na , na > result_; typedef lcm< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< lcm< T1 , T2 > > : int_<2> { }; template<> struct template_arity< lcm< na , na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    , T n2
    >
struct lcm_c
    : lcm<integral_c<T,n1>,integral_c<T,n2> >
{
};


namespace aux {




  template< typename T1, boost::intmax_t n1, bool n1_is_0
                          , typename T2, boost::intmax_t n2, bool n2_is_0 >
      struct lcm_aux
          : abs<integral_c< typename aux::largest_int<T1, T2>::type,
              ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
          > >
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
      struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
      struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
      {};
# 112 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
}

template<>
struct lcm_impl<integral_c_tag, integral_c_tag>
{
    template< typename N1, typename N2 > struct apply
        : abs<aux::lcm_aux< typename N1::value_type, N1::value, N1::value==0,
                        typename N2::value_type, N2::value, N2::value==0 > >
    {
    };
};

}}
# 40 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 41 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 42 "/usr/include/boost/ratio/ratio.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 44 "/usr/include/boost/ratio/ratio.hpp" 2 3 4

# 1 "/usr/include/boost/utility/enable_if.hpp" 1 3 4
# 24 "/usr/include/boost/utility/enable_if.hpp" 3 4
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> {};

}
# 46 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/integer_traits.hpp" 1 3 4
# 23 "/usr/include/boost/integer_traits.hpp" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 24 "/usr/include/boost/integer_traits.hpp" 2 3 4



# 1 "/usr/include/wchar.h" 1 3 4
# 28 "/usr/include/boost/integer_traits.hpp" 2 3 4
# 39 "/usr/include/boost/integer_traits.hpp" 3 4
       
# 40 "/usr/include/boost/integer_traits.hpp" 3


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, (-127 - 1), 127>
{ };

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, (-2147483647L - 1), 2147483647L>
# 130 "/usr/include/boost/integer_traits.hpp" 3
{ };


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, (-2147483647L - 1L), 2147483647L>
{ };

template<>
class integer_traits<unsigned long>
  : public std::numeric_limits<unsigned long>,
    public detail::integer_traits_base<unsigned long, 0, (2147483647L * 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)>
{ };
# 256 "/usr/include/boost/integer_traits.hpp" 3
}
# 47 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/ratio_fwd.hpp" 1 3 4
# 37 "/usr/include/boost/ratio/ratio_fwd.hpp" 3 4
namespace boost
{
# 47 "/usr/include/boost/ratio/ratio_fwd.hpp" 3 4
template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;


template <class R1, class R2> struct ratio_add;
template <class R1, class R2> struct ratio_subtract;
template <class R1, class R2> struct ratio_multiply;
template <class R1, class R2> struct ratio_divide;


template <class R1, class R2> struct ratio_equal;
template <class R1, class R2> struct ratio_not_equal;
template <class R1, class R2> struct ratio_less;
template <class R1, class R2> struct ratio_less_equal;
template <class R1, class R2> struct ratio_greater;
template <class R1, class R2> struct ratio_greater_equal;


typedef ratio<1LL, 1000000000000000000LL> atto;
typedef ratio<1LL, 1000000000000000LL> femto;
typedef ratio<1LL, 1000000000000LL> pico;
typedef ratio<1LL, 1000000000LL> nano;
typedef ratio<1LL, 1000000LL> micro;
typedef ratio<1LL, 1000LL> milli;
typedef ratio<1LL, 100LL> centi;
typedef ratio<1LL, 10LL> deci;
typedef ratio< 10LL, 1LL> deca;
typedef ratio< 100LL, 1LL> hecto;
typedef ratio< 1000LL, 1LL> kilo;
typedef ratio< 1000000LL, 1LL> mega;
typedef ratio< 1000000000LL, 1LL> giga;
typedef ratio< 1000000000000LL, 1LL> tera;
typedef ratio< 1000000000000000LL, 1LL> peta;
typedef ratio<1000000000000000000LL, 1LL> exa;

}
# 48 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 1 3 4
# 38 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 39 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 40 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 42 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
# 55 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
       
# 56 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3


namespace boost
{





namespace ratio_detail
{

  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
  class br_add;

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_add<X, Y, 1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static char __boost_ratio_test_77[(X <= max - Y)?1:-1];
  public:
      static const boost::intmax_t value = X + Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_add<X, Y, 0>
  {
  public:
      static const boost::intmax_t value = X;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_add<X, Y, -1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static char __boost_ratio_test_95[(min - Y <= X)?1:-1];
  public:
      static const boost::intmax_t value = X + Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
  class br_sub;

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_sub<X, Y, 1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static char __boost_ratio_test_109[(min + Y <= X)?1:-1];
  public:
      static const boost::intmax_t value = X - Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_sub<X, Y, 0>
  {
  public:
      static const boost::intmax_t value = X;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_sub<X, Y, -1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static char __boost_ratio_test_127[(X <= max + Y)?1:-1];
  public:
      static const boost::intmax_t value = X - Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_mul
  {
      static const boost::intmax_t nan =
          boost::intmax_t(1ULL << (sizeof(boost::intmax_t) * 8 - 1));
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value;
      static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value;

      static char __boost_ratio_test_143[(X != nan)?1:-1];
      static char __boost_ratio_test_144[(Y != nan)?1:-1];
      static char __boost_ratio_test_145[(a_x <= max / a_y)?1:-1];
  public:
      static const boost::intmax_t value = X * Y;
  };

  template <boost::intmax_t Y>
  class br_mul<0, Y>
  {
  public:
      static const boost::intmax_t value = 0;
  };

  template <boost::intmax_t X>
  class br_mul<X, 0>
  {
  public:
      static const boost::intmax_t value = 0;
  };

  template <>
  class br_mul<0, 0>
  {
  public:
      static const boost::intmax_t value = 0;
  };


  template <boost::intmax_t X, boost::intmax_t Y>
  class br_div
  {
      static const boost::intmax_t nan = boost::intmax_t(1ULL << (sizeof(boost::intmax_t) * 8 - 1));
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static char __boost_ratio_test_179[(X != nan)?1:-1];
      static char __boost_ratio_test_180[(Y != nan)?1:-1];
      static char __boost_ratio_test_181[(Y != 0)?1:-1];
  public:
      static const boost::intmax_t value = X / Y;
  };


  template <class R1, class R2> struct ratio_add;
  template <class R1, class R2> struct ratio_subtract;
  template <class R1, class R2> struct ratio_multiply;
  template <class R1, class R2> struct ratio_divide;

  template <class R1, class R2>
  struct ratio_add
  {



  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:

      typedef typename ratio_multiply
         <
             ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
             ratio
             <
                 boost::ratio_detail::br_add
                 <
                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
                 >::value,
                 R2::den
             >
         >::type type;
  };
  template <class R, boost::intmax_t D>
  struct ratio_add<R, ratio<0,D> >
  {
    typedef R type;
  };

  template <class R1, class R2>
  struct ratio_subtract
  {



  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:

      typedef typename ratio_multiply
         <
             ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
             ratio
             <
                 boost::ratio_detail::br_sub
                 <
                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
                 >::value,
                 R2::den
             >
         >::type type;
  };

  template <class R, boost::intmax_t D>
  struct ratio_subtract<R, ratio<0,D> >
  {
    typedef R type;
  };

  template <class R1, class R2>
  struct ratio_multiply
  {


  private:
     static const boost::intmax_t gcd_n1_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value;
     static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value;
  public:
      typedef typename ratio
         <
             boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
             boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
         >::type type;
  };

  template <class R1, class R2>
  struct ratio_divide
  {


  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:
      typedef typename ratio
         <
             boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
             boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
         >::type type;
  };
  template <class R1, class R2>
  struct is_evenly_divisible_by
  {
  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:
      typedef integral_constant<bool,
             ((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1)
      > type;
  };

  template <class T>
  struct is_ratio : public boost::false_type
  {};
  template <boost::intmax_t N, boost::intmax_t D>
  struct is_ratio<ratio<N, D> > : public boost::true_type
  {};

  template <class R1, class R2,
            boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den,
            boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den>
  struct ratio_less1
  {
    static const bool value = Q1 < Q2;
  };

  template <class R1, class R2, boost::intmax_t Q>
  struct ratio_less1<R1, R2, Q, 0, Q, 0>
  {
    static const bool value = false;
  };

  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2>
  struct ratio_less1<R1, R2, Q, 0, Q, M2>
  {
    static const bool value = true;
  };

  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1>
  struct ratio_less1<R1, R2, Q, M1, Q, 0>
  {
    static const bool value = false;
  };

  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2>
  struct ratio_less1<R1, R2, Q, M1, Q, M2>
  {
    static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1>
                                            >::value;
  };

  template <
      class R1,
      class R2,
      boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value,
    boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value
>
  struct ratio_less
  {
      static const bool value = S1 < S2;
  };

  template <class R1, class R2>
  struct ratio_less<R1, R2, 1LL, 1LL>
  {
      static const bool value = ratio_less1<R1, R2>::value;
  };

  template <class R1, class R2>
  struct ratio_less<R1, R2, -1LL, -1LL>
  {
      static const bool value = ratio_less1<ratio<-R2::num, R2::den>,
                                            ratio<-R1::num, R1::den> >::value;
  };


}

}
# 49 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 63 "/usr/include/boost/ratio/ratio.hpp" 3 4
       
# 64 "/usr/include/boost/ratio/ratio.hpp" 3


namespace boost
{
# 76 "/usr/include/boost/ratio/ratio.hpp" 3
template <boost::intmax_t N, boost::intmax_t D>
class ratio
{
    static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
    static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
    static char __boost_ratio_test_81[(ABS_N >= 0)?1:-1];
    static char __boost_ratio_test_82[(ABS_D > 0)?1:-1];
    static char __boost_ratio_test_83[(D != 0)?1:-1];
    static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
      * mpl::sign_c<boost::intmax_t,D>::value;
    static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
public:
    static const boost::intmax_t num = SIGN_N * ABS_N / GCD;
    static const boost::intmax_t den = ABS_D / GCD;
# 119 "/usr/include/boost/ratio/ratio.hpp" 3
    typedef ratio<num, den> type;
};


template <boost::intmax_t N, boost::intmax_t D>
const boost::intmax_t ratio<N, D>::num;
template <boost::intmax_t N, boost::intmax_t D>
const boost::intmax_t ratio<N, D>::den;
# 135 "/usr/include/boost/ratio/ratio.hpp" 3
template <class R1, class R2>
struct ratio_add
: boost::ratio_detail::ratio_add<R1, R2>::type
{
};

template <class R1, class R2>
struct ratio_subtract
: boost::ratio_detail::ratio_subtract<R1, R2>::type
{
};

template <class R1, class R2>
struct ratio_multiply
: boost::ratio_detail::ratio_multiply<R1, R2>::type
{
};

template <class R1, class R2>
struct ratio_divide
: boost::ratio_detail::ratio_divide<R1, R2>::type
{
};
# 167 "/usr/include/boost/ratio/ratio.hpp" 3
template <class R1, class R2>
struct ratio_equal
    : public boost::integral_constant<bool,
                               (R1::num == R2::num && R1::den == R2::den)>
{};

template <class R1, class R2>
struct ratio_not_equal
    : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
{};



template <class R1, class R2>
struct ratio_less
    : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
{};

template <class R1, class R2>
struct ratio_less_equal
    : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
{};

template <class R1, class R2>
struct ratio_greater
    : boost::integral_constant<bool, ratio_less<R2, R1>::value>
{};

template <class R1, class R2>
struct ratio_greater_equal
    : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
{};

template <class R1, class R2>
struct ratio_gcd :
    ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
        mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
{
};
# 230 "/usr/include/boost/ratio/ratio.hpp" 3
}
# 42 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/common_type.hpp" 1 3 4
# 29 "/usr/include/boost/type_traits/common_type.hpp" 3 4
# 1 "/usr/include/boost/typeof/typeof.hpp" 1 3 4
# 208 "/usr/include/boost/typeof/typeof.hpp" 3 4
# 1 "/usr/include/boost/typeof/message.hpp" 1 3 4
# 209 "/usr/include/boost/typeof/typeof.hpp" 2 3 4
# 1 "/usr/include/boost/typeof/native.hpp" 1 3 4
# 21 "/usr/include/boost/typeof/native.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_function.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_function.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/false_result.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/false_result.hpp" 3 4
namespace boost {
namespace type_traits {


struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};

}}
# 16 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
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; };
# 203 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
}
}
# 20 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4







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>
{
};
# 95 "/usr/include/boost/type_traits/is_function.hpp" 3 4
}






template< typename T > struct is_function : public ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { public: };




}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 110 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
# 22 "/usr/include/boost/typeof/native.hpp" 2 3 4


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&);

}}
# 210 "/usr/include/boost/typeof/typeof.hpp" 2 3 4
# 30 "/usr/include/boost/type_traits/common_type.hpp" 2 3 4
# 54 "/usr/include/boost/type_traits/common_type.hpp" 3 4
# 1 "/usr/include/boost/utility/declval.hpp" 1 3 4
# 15 "/usr/include/boost/utility/declval.hpp" 3 4
# 1 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_void.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_void.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/is_void.hpp" 2 3 4

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: };




}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 37 "/usr/include/boost/type_traits/is_void.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 2 3 4
# 34 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
namespace boost {

namespace type_traits_detail {

    template <typename T, bool b>
    struct add_rvalue_reference_helper
    { typedef T type; };
# 50 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
    template <typename T>
    struct add_rvalue_reference_imp
    {
       typedef typename boost::type_traits_detail::add_rvalue_reference_helper
                  <T, (is_void<T>::value == false && is_reference<T>::value == false) >::type type;
    };

}

template< typename T > struct add_rvalue_reference { public: typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type; };

}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 64 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 2 3 4
# 16 "/usr/include/boost/utility/declval.hpp" 2 3 4
# 38 "/usr/include/boost/utility/declval.hpp" 3 4
namespace boost {


    template <typename T>
    typename add_rvalue_reference<T>::type declval() ;




}
# 55 "/usr/include/boost/type_traits/common_type.hpp" 2 3 4
# 66 "/usr/include/boost/type_traits/common_type.hpp" 3 4
namespace boost {






    template <class T, class U = void, class V = void>
    struct common_type
    {
    public:
        typedef typename common_type<typename common_type<T, U>::type, V>::type type;
    };




    template<typename T>



    struct common_type<T, void, void>


    {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(T) > 0) == 0 ? false : true) >)> boost_static_assert_typedef_91;
    public:
        typedef T type;
    };


namespace type_traits_detail {

    template <class T, class U>
    struct common_type_2
    {
    private:
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(T) > 0) == 0 ? false : true) >)> boost_static_assert_typedef_103;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(U) > 0) == 0 ? false : true) >)> boost_static_assert_typedef_104;
        static bool declval_bool();
        static typename add_rvalue_reference<T>::type declval_T();
        static typename add_rvalue_reference<U>::type declval_U();
        static typename add_rvalue_reference<bool>::type declval_b();
# 120 "/usr/include/boost/type_traits/common_type.hpp" 3 4
    public:
        typedef __typeof__(boost::type_of::ensure_obj(declval_b() ? declval_T() : declval_U())) type;






    };

    template <class T>
    struct common_type_2<T, T>
    {
        typedef T type;
    };
    }





    template <class T, class U>
    struct common_type<T, U, void>

    : public type_traits_detail::common_type_2<T,U>
    { };
# 156 "/usr/include/boost/type_traits/common_type.hpp" 3 4
}
# 43 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_arithmetic.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_integral.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4

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: };
# 65 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
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: };
# 79 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 82 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_float.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_float.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4

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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4

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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 50 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
# 44 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_convertible.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_array.hpp" 1 3 4
# 24 "/usr/include/boost/type_traits/is_array.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 25 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 28 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4

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: };
# 87 "/usr/include/boost/type_traits/is_array.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 90 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4




# 1 "/usr/include/boost/type_traits/is_abstract.hpp" 1 3 4
# 62 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 63 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4


namespace boost {
namespace detail{


template <class T>
struct is_abstract_imp
{
   static const bool value = __is_abstract(T);
};
# 141 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
}


template< typename T > struct is_abstract : public ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { public: };




}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 152 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
# 25 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 1 3 4
# 9 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/add_reference.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4

namespace boost {

namespace detail {
# 59 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
template <typename T>
struct add_reference_rvalue_layer
{
    typedef T& type;
};
# 73 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
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; };







}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 106 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
# 10 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4

namespace boost{

template< typename T > struct add_lvalue_reference { public: typedef typename boost::add_reference<T>::type type; };





}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 37 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 38 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4

namespace boost {
# 53 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
namespace detail {
# 120 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    template <typename T> any_conversion(const T&);
    template <typename T> any_conversion(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
{
    typedef typename add_lvalue_reference<From>::type lvalue_type;
    typedef typename add_rvalue_reference<From>::type rvalue_type;
    static lvalue_type _m_from;





    static bool const value =
        sizeof( boost::detail::checker<To>::_m_check(_m_from, 0) )
        == sizeof(::boost::type_traits::yes_type);

};
# 351 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
template <typename From, typename To>
struct is_convertible_impl
{
    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<From,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_function<To>::value >::value >::value)
# 367 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
         ;
};


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
{};
# 456 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
    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); };
# 466 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
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: };







}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 491 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 45 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_floating_point.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_floating_point.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/is_floating_point.hpp" 2 3 4

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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_floating_point.hpp" 2 3 4
# 46 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_unsigned.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_enum.hpp" 1 3 4
# 32 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 33 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4

namespace boost {
# 181 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
template< typename T > struct is_enum : public ::boost::integral_constant<bool,__is_enum(T)> { public: };



}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 188 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4




# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4

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;
};
# 121 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
}






template< typename T > struct is_unsigned : public ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { public: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 134 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4
# 47 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 1 3 4
# 16 "/usr/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 3 4
namespace boost {
namespace chrono {
namespace chrono_detail {




  template <class R1, class R2>
  struct is_evenly_divisible_by : public boost::ratio_detail::is_evenly_divisible_by<R1, R2>
  {};

}
}
}
# 48 "/usr/include/boost/chrono/duration.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 50 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 63 "/usr/include/boost/chrono/duration.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 64 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 73 "/usr/include/boost/chrono/duration.hpp" 3 4
namespace boost {
namespace chrono {

    template <class Rep, class Period = ratio<1> >
    class duration;

    namespace detail
    {
    template <class T>
      struct is_duration
        : boost::false_type {};

    template <class Rep, class Period>
      struct is_duration<duration<Rep, Period> >
        : boost::true_type {};

    template <class Duration, class Rep, bool = is_duration<Rep>::value>
    struct duration_divide_result
    {
    };

    template <class Duration, class Rep2,
        bool = (
                    ((boost::is_convertible<typename Duration::rep,
                        typename common_type<typename Duration::rep, Rep2>::type>::value))
                && ((boost::is_convertible<Rep2,
                        typename common_type<typename Duration::rep, Rep2>::type>::value))
                )
        >
    struct duration_divide_imp
    {
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_divide_imp<duration<Rep1, Period>, Rep2, true>
    {
        typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_divide_result<duration<Rep1, Period>, Rep2, false>
        : duration_divide_imp<duration<Rep1, Period>, Rep2>
    {
    };


    template <class Rep, class Duration, bool = is_duration<Rep>::value>
    struct duration_divide_result2
    {
    };

    template <class Rep, class Duration,
        bool = (
                    ((boost::is_convertible<typename Duration::rep,
                        typename common_type<typename Duration::rep, Rep>::type>::value))
                && ((boost::is_convertible<Rep,
                        typename common_type<typename Duration::rep, Rep>::type>::value))
                )
        >
    struct duration_divide_imp2
    {
    };

    template <class Rep1, class Rep2, class Period >
    struct duration_divide_imp2<Rep1, duration<Rep2, Period>, true>
    {

        typedef double type;
    };

    template <class Rep1, class Rep2, class Period >
    struct duration_divide_result2<Rep1, duration<Rep2, Period>, false>
        : duration_divide_imp2<Rep1, duration<Rep2, Period> >
    {
    };


    template <class Duration, class Rep, bool = is_duration<Rep>::value>
    struct duration_modulo_result
    {
    };

    template <class Duration, class Rep2,
        bool = (



    boost::is_convertible<Rep2,
                        typename common_type<typename Duration::rep, Rep2>::type>::value
                )
        >
    struct duration_modulo_imp
    {
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_modulo_imp<duration<Rep1, Period>, Rep2, true>
    {
        typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_modulo_result<duration<Rep1, Period>, Rep2, false>
        : duration_modulo_imp<duration<Rep1, Period>, Rep2>
    {
    };

}
}




template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>,
                     chrono::duration<Rep2, Period2> >;


namespace chrono {


    template <class Rep> struct treat_as_floating_point;
    template <class Rep> struct duration_values;


    typedef duration<boost::int_least64_t, nano> nanoseconds;
    typedef duration<boost::int_least64_t, micro> microseconds;
    typedef duration<boost::int_least64_t, milli> milliseconds;
    typedef duration<boost::int_least64_t> seconds;
    typedef duration<boost::int_least32_t, ratio< 60> > minutes;
    typedef duration<boost::int_least32_t, ratio<3600> > hours;





namespace detail
{
# 223 "/usr/include/boost/chrono/duration.hpp" 3 4
    template <class FromDuration, class ToDuration,
              class Period,
              bool PeriodNumEq1,
              bool PeriodDenEq1>
    struct duration_cast_aux;





    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, true, true>
    {
        ToDuration operator()(const FromDuration& fd) const
        {
            return ToDuration(static_cast<typename ToDuration::rep>(fd.count()));
        }
    };







    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, true, false>
    {
        ToDuration operator()(const FromDuration& fd) const
        {
            typedef typename common_type<
                typename ToDuration::rep,
                typename FromDuration::rep,
                boost::intmax_t>::type C;
            return ToDuration(static_cast<typename ToDuration::rep>(
                              static_cast<C>(fd.count()) / static_cast<C>(Period::den)));
        }
    };






    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, false, true>
    {
        ToDuration operator()(const FromDuration& fd) const
        {
            typedef typename common_type<
              typename ToDuration::rep,
              typename FromDuration::rep,
              boost::intmax_t>::type C;
            return ToDuration(static_cast<typename ToDuration::rep>(
                              static_cast<C>(fd.count()) * static_cast<C>(Period::num)));
        }
    };







    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, false, false>
    {
        ToDuration operator()(const FromDuration& fd) const
        {
            typedef typename common_type<
              typename ToDuration::rep,
              typename FromDuration::rep,
              boost::intmax_t>::type C;
            return ToDuration(static_cast<typename ToDuration::rep>(
               static_cast<C>(fd.count()) * static_cast<C>(Period::num)
                 / static_cast<C>(Period::den)));
        }
    };

    template <class FromDuration, class ToDuration>
    struct duration_cast {
        typedef typename ratio_divide<typename FromDuration::period,
              typename ToDuration::period>::type Period;
        typedef duration_cast_aux<
            FromDuration,
            ToDuration,
            Period,
            Period::num == 1,
            Period::den == 1
        > Aux;
        ToDuration operator()(const FromDuration& fd) const
        {
            return Aux()(fd);
        }
    };

}
# 333 "/usr/include/boost/chrono/duration.hpp" 3 4
    template <class Rep>
    struct treat_as_floating_point : boost::is_floating_point<Rep> {};





namespace detail {
    template <class T, bool = is_arithmetic<T>::value>
    struct chrono_numeric_limits {
        static T lowest() throw() {return (std::numeric_limits<T>::min) ();}
    };

    template <class T>
    struct chrono_numeric_limits<T,true> {
        static T lowest() throw() {return (std::numeric_limits<T>::min) ();}
    };

    template <>
    struct chrono_numeric_limits<float,true> {
        static float lowest() throw()
        {
            return -(std::numeric_limits<float>::max) ();
        }
    };

    template <>
    struct chrono_numeric_limits<double,true> {
        static double lowest() throw()
        {
            return -(std::numeric_limits<double>::max) ();
        }
    };

    template <>
    struct chrono_numeric_limits<long double,true> {
        static long double lowest() throw()
        {
            return -(std::numeric_limits<long double>::max)();
        }
    };

    template <class T>
    struct numeric_limits : chrono_numeric_limits<typename remove_cv<T>::type>
    {};

}
template <class Rep>
struct duration_values
{
    static Rep zero() {return Rep(0);}
    static Rep max ()
    {
        return (std::numeric_limits<Rep>::max)();
    }

    static Rep min ()
    {
        return detail::numeric_limits<Rep>::lowest();
    }
};

}





template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>,
                   chrono::duration<Rep2, Period2> >
{
  typedef chrono::duration<typename common_type<Rep1, Rep2>::type,
                      typename boost::ratio_gcd<Period1, Period2>::type> type;
};
# 417 "/usr/include/boost/chrono/duration.hpp" 3 4
namespace chrono {

    template <class Rep, class Period>
    class __attribute__((visibility("default"))) duration
    {

    static char boost_chrono_test_424[(!boost::chrono::detail::is_duration<Rep>::value)?1:-1]
                                                                             ;
    static char boost_chrono_test_426[(boost::ratio_detail::is_ratio<typename Period::type>::value)?1:-1]
                                                                                       ;
    static char boost_chrono_test_428[(Period::num>0)?1:-1]
                                                              ;
    public:
        typedef Rep rep;
        typedef Period period;
    private:
        rep rep_;
    public:

       
        duration() : rep_(duration_values<rep>::zero()) { }
        template <class Rep2>
        __attribute__((visibility("default"))) inline
        explicit duration(const Rep2& r
        , typename boost::enable_if <
                    mpl::and_ <
                        boost::is_convertible<Rep2, rep>,
                        mpl::or_ <
                            treat_as_floating_point<rep>,
                            mpl::and_ <
                                mpl::not_ < treat_as_floating_point<rep> >,
                                mpl::not_ < treat_as_floating_point<Rep2> >
                            >
                        >
                    >
                >::type* = 0
            ) : rep_(r) { }


        duration& operator=(const duration& rhs)
        {
            if (&rhs != this) rep_= rhs.rep_;
            return *this;
        }


        template <class Rep2, class Period2>
       
        duration(const duration<Rep2, Period2>& d
        , typename boost::enable_if <
                    mpl::or_ <
                        treat_as_floating_point<rep>,
                        mpl::and_ <
                            chrono_detail::is_evenly_divisible_by<Period2, period>,
                            mpl::not_ < treat_as_floating_point<Rep2> >
                        >
                    >
                >::type* = 0
        )
            : rep_(chrono::detail::duration_cast<duration<Rep2, Period2>, duration>()(d).count()) {}



       
        rep count() const {return rep_;}



       
        duration operator+() const {return duration(rep_);;}
       
        duration operator-() const {return duration(-rep_);}
        duration& operator++() {++rep_; return *this;}
        duration operator++(int) {return duration(rep_++);}
        duration& operator--() {--rep_; return *this;}
        duration operator--(int) {return duration(rep_--);}

        duration& operator+=(const duration& d)
        {
            rep_ += d.count(); return *this;
        }
        duration& operator-=(const duration& d)
        {
            rep_ -= d.count(); return *this;
        }

        duration& operator*=(const rep& rhs) {rep_ *= rhs; return *this;}
        duration& operator/=(const rep& rhs) {rep_ /= rhs; return *this;}
        duration& operator%=(const rep& rhs) {rep_ %= rhs; return *this;}
        duration& operator%=(const duration& rhs)
        {
            rep_ %= rhs.count(); return *this;
        }


        static duration zero()
        {
            return duration(duration_values<rep>::zero());
        }
        static duration min ()
        {
            return duration((duration_values<rep>::min)());
        }
        static duration max ()
        {
            return duration((duration_values<rep>::max)());
        }
    };







    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator+(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
      typedef typename common_type<duration<Rep1, Period1>,
        duration<Rep2, Period2> >::type CD;
      return CD(CD(lhs).count()+CD(rhs).count());
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator-(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
      typedef typename common_type<duration<Rep1, Period1>,
            duration<Rep2, Period2> >::type CD;
      return CD(CD(lhs).count()-CD(rhs).count());
    }



    template <class Rep1, class Period, class Rep2>
    inline
    typename boost::enable_if <
        mpl::and_ <
        boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
        boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
        >,
        duration<typename common_type<Rep1, Rep2>::type, Period>
    >::type
    operator*(const duration<Rep1, Period>& d, const Rep2& s)
    {
      typedef typename common_type<Rep1, Rep2>::type CRRRRR;
      typedef duration<CRRRRR, Period> CD;
      return CD(CD(d).count()*static_cast<CRRRRR>(s));
    }

    template <class Rep1, class Period, class Rep2>
    inline
    typename boost::enable_if <
        mpl::and_ <
        boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
        boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
        >,
        duration<typename common_type<Rep1, Rep2>::type, Period>
    >::type
    operator*(const Rep1& s, const duration<Rep2, Period>& d)
    {
        return d * s;
    }



    template <class Rep1, class Period, class Rep2>
    inline
    typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
      typename boost::chrono::detail::duration_divide_result<
        duration<Rep1, Period>, Rep2>::type
    >::type
    operator/(const duration<Rep1, Period>& d, const Rep2& s)
    {
        typedef typename common_type<Rep1, Rep2>::type CRRRRR;
        typedef duration<CRRRRR, Period> CD;

      return CD(CD(d).count()/static_cast<CRRRRR>(s));
    }

    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    typename common_type<Rep1, Rep2>::type
    operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
    {
        typedef typename common_type<duration<Rep1, Period1>,
                                   duration<Rep2, Period2> >::type CD;
        return CD(lhs).count() / CD(rhs).count();
    }
# 631 "/usr/include/boost/chrono/duration.hpp" 3 4
    template <class Rep1, class Period, class Rep2>
    inline
    typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
      typename boost::chrono::detail::duration_modulo_result<
        duration<Rep1, Period>, Rep2>::type
    >::type
    operator%(const duration<Rep1, Period>& d, const Rep2& s)
    {
        typedef typename common_type<Rep1, Rep2>::type CRRRRR;
        typedef duration<CRRRRR, Period> CD;

      return CD(CD(d).count()%static_cast<CRRRRR>(s));
    }

    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator%(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs) {
        typedef typename common_type<duration<Rep1, Period1>,
                                 duration<Rep2, Period2> >::type CD;

      return CD(CD(lhs).count()%CD(rhs).count());
    }






namespace detail
{
    template <class LhsDuration, class RhsDuration>
    struct duration_eq
    {
      bool operator()(const LhsDuration& lhs, const RhsDuration& rhs)
        {
            typedef typename common_type<LhsDuration, RhsDuration>::type CD;
            return CD(lhs).count() == CD(rhs).count();
        }
    };

    template <class LhsDuration>
    struct duration_eq<LhsDuration, LhsDuration>
    {
      bool operator()(const LhsDuration& lhs, const LhsDuration& rhs)
        {
            return lhs.count() == rhs.count();
        }
    };

    template <class LhsDuration, class RhsDuration>
    struct duration_lt
    {
      bool operator()(const LhsDuration& lhs, const RhsDuration& rhs)
        {
            typedef typename common_type<LhsDuration, RhsDuration>::type CD;
            return CD(lhs).count() < CD(rhs).count();
        }
    };

    template <class LhsDuration>
    struct duration_lt<LhsDuration, LhsDuration>
    {
      bool operator()(const LhsDuration& lhs, const LhsDuration& rhs)
        {
            return lhs.count() < rhs.count();
        }
    };

}



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    bool
    operator==(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return boost::chrono::detail::duration_eq<
            duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    bool
    operator!=(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return !(lhs == rhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    bool
    operator< (const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return boost::chrono::detail::duration_lt<
          duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    bool
    operator> (const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return rhs < lhs;
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    bool
    operator<=(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return !(rhs < lhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline
    bool
    operator>=(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return !(lhs < rhs);
    }






    template <class ToDuration, class Rep, class Period>
    inline
    typename boost::enable_if <
      boost::chrono::detail::is_duration<ToDuration>, ToDuration>::type
    duration_cast(const duration<Rep, Period>& fd)
    {
        return boost::chrono::detail::duration_cast<
          duration<Rep, Period>, ToDuration>()(fd);
    }

}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 792 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 21 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4
# 30 "/usr/include/boost/thread/pthread/timespec.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 31 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4

namespace boost
{
  namespace detail
  {

    inline struct timespec to_timespec(boost::system_time const& abs_time)
    {
      struct timespec timeout = { 0,0};
      boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);

      timeout.tv_sec=time_since_epoch.total_seconds();
      timeout.tv_nsec=(long)(time_since_epoch.fractional_seconds()*(1000000000l/time_since_epoch.ticks_per_second()));
      return timeout;
    }


    inline timespec to_timespec(chrono::nanoseconds const& ns)
    {
      struct timespec ts;
      ts.tv_sec = static_cast<long>(chrono::duration_cast<chrono::seconds>(ns).count());
      ts.tv_nsec = static_cast<long>((ns - chrono::duration_cast<chrono::seconds>(ns)).count());
      return ts;
    }



    inline timespec to_timespec(boost::intmax_t const& ns)
    {
      boost::intmax_t s = ns / 1000000000l;
      struct timespec ts;
      ts.tv_sec = static_cast<long> (s);
      ts.tv_nsec = static_cast<long> (ns - s * 1000000000l);
      return ts;
    }
    inline boost::intmax_t to_nanoseconds_int_max(timespec const& ts)
    {
      return static_cast<boost::intmax_t>(ts.tv_sec) * 1000000000l + ts.tv_nsec;
    }
    inline bool timespec_ge_zero(timespec const& ts)
    {
      return (ts.tv_sec >= 0) || (ts.tv_nsec >= 0);
    }
    inline timespec timespec_now()
    {
      timespec ts;







      if ( ::clock_gettime( 0, &ts ) )
      {
        ((0 && "Boost::Thread - Internal Error") ? static_cast<void> (0) : __assert_fail ("0 && \"Boost::Thread - Internal Error\"", "/usr/include/boost/thread/pthread/timespec.hpp", 86, __PRETTY_FUNCTION__));
      }

      return ts;
    }
    inline timespec timespec_zero()
    {
      timespec ts;
      ts.tv_sec = 0;
      ts.tv_nsec = 0;
      return ts;
    }
    inline timespec timespec_plus(timespec const& lhs, timespec const& rhs)
    {
      return to_timespec(to_nanoseconds_int_max(lhs) + to_nanoseconds_int_max(rhs));
    }
    inline timespec timespec_minus(timespec const& lhs, timespec const& rhs)
    {
      return to_timespec(to_nanoseconds_int_max(lhs) - to_nanoseconds_int_max(rhs));
    }
    inline bool timespec_gt(timespec const& lhs, timespec const& rhs)
    {
      return to_nanoseconds_int_max(lhs) > to_nanoseconds_int_max(rhs);
    }
    inline bool timespec_ge(timespec const& lhs, timespec const& rhs)
    {
      return to_nanoseconds_int_max(lhs) >= to_nanoseconds_int_max(rhs);
    }

  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 119 "/usr/include/boost/thread/pthread/timespec.hpp" 2 3 4
# 10 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 1 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 1 3 4
# 10 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 11 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 13 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4

namespace boost
{
    namespace pthread
    {
        class pthread_mutex_scoped_lock
        {
            pthread_mutex_t* m;
            bool locked;
        public:
            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_):
                m(m_),locked(true)
            {
                ((!pthread_mutex_lock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_lock(m)", "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp", 26, __PRETTY_FUNCTION__));
            }
            void unlock()
            {
                ((!pthread_mutex_unlock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_unlock(m)", "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp", 30, __PRETTY_FUNCTION__));
                locked=false;
            }

            ~pthread_mutex_scoped_lock()
            {
                if(locked)
                {
                    unlock();
                }
            }

        };

        class pthread_mutex_scoped_unlock
        {
            pthread_mutex_t* m;
        public:
            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_):
                m(m_)
            {
                ((!pthread_mutex_unlock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_unlock(m)", "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp", 51, __PRETTY_FUNCTION__));
            }
            ~pthread_mutex_scoped_unlock()
            {
                ((!pthread_mutex_lock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_lock(m)", "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp", 55, __PRETTY_FUNCTION__));
            }

        };
    }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 63 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
# 11 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4

# 1 "/usr/include/boost/thread/pthread/thread_data.hpp" 1 3 4
# 10 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
# 1 "/usr/include/boost/thread/exceptions.hpp" 1 3 4
# 22 "/usr/include/boost/thread/exceptions.hpp" 3 4
# 1 "/usr/include/boost/system/system_error.hpp" 1 3 4
# 13 "/usr/include/boost/system/system_error.hpp" 3 4
# 1 "/usr/include/c++/4.8/cassert" 1 3 4
# 41 "/usr/include/c++/4.8/cassert" 3 4
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 14 "/usr/include/boost/system/system_error.hpp" 2 3 4
# 1 "/usr/include/boost/system/error_code.hpp" 1 3 4
# 14 "/usr/include/boost/system/error_code.hpp" 3 4
# 1 "/usr/include/boost/system/config.hpp" 1 3 4
# 14 "/usr/include/boost/system/config.hpp" 3 4
# 1 "/usr/include/boost/system/api_config.hpp" 1 3 4
# 15 "/usr/include/boost/system/config.hpp" 2 3 4
# 65 "/usr/include/boost/system/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 66 "/usr/include/boost/system/config.hpp" 2 3 4
# 15 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 16 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 17 "/usr/include/boost/system/error_code.hpp" 2 3 4

# 1 "/usr/include/boost/noncopyable.hpp" 1 3 4
# 12 "/usr/include/boost/noncopyable.hpp" 3 4
namespace boost {






namespace noncopyable_
{
  class noncopyable
  {
   protected:
      noncopyable() {}
      ~noncopyable() {}
   private:
      noncopyable( const noncopyable& );
      const noncopyable& operator=( const noncopyable& );
  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 19 "/usr/include/boost/system/error_code.hpp" 2 3 4







# 1 "/usr/include/boost/cerrno.hpp" 1 3 4
# 13 "/usr/include/boost/cerrno.hpp" 3 4
# 1 "/usr/include/c++/4.8/cerrno" 1 3 4
# 39 "/usr/include/c++/4.8/cerrno" 3 4
       
# 40 "/usr/include/c++/4.8/cerrno" 3

# 1 "/usr/include/errno.h" 1 3 4
# 31 "/usr/include/errno.h" 3 4
extern "C" {



# 1 "/usr/include/i386-linux-gnu/bits/errno.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/i386-linux-gnu/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4



# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 5 "/usr/include/asm-generic/errno.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/asm/errno.h" 2 3 4
# 1 "/usr/include/linux/errno.h" 2 3 4
# 25 "/usr/include/i386-linux-gnu/bits/errno.h" 2 3 4
# 50 "/usr/include/i386-linux-gnu/bits/errno.h" 3 4
extern int *__errno_location (void) throw () __attribute__ ((__const__));
# 36 "/usr/include/errno.h" 2 3 4
# 54 "/usr/include/errno.h" 3 4
extern char *program_invocation_name, *program_invocation_short_name;



}
# 68 "/usr/include/errno.h" 3 4
typedef int error_t;
# 42 "/usr/include/c++/4.8/cerrno" 2 3
# 14 "/usr/include/boost/cerrno.hpp" 2 3 4
# 27 "/usr/include/boost/system/error_code.hpp" 2 3 4





# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 33 "/usr/include/boost/system/error_code.hpp" 2 3 4

namespace boost
{
  namespace system
  {

    class error_code;
    class error_condition;



    template< class T >
    struct is_error_code_enum { static const bool value = false; };

    template< class T >
    struct is_error_condition_enum { static const bool value = false; };



    namespace errc
    {
      enum errc_t
      {
        success = 0,
        address_family_not_supported = 97,
        address_in_use = 98,
        address_not_available = 99,
        already_connected = 106,
        argument_list_too_long = 7,
        argument_out_of_domain = 33,
        bad_address = 14,
        bad_file_descriptor = 9,
        bad_message = 74,
        broken_pipe = 32,
        connection_aborted = 103,
        connection_already_in_progress = 114,
        connection_refused = 111,
        connection_reset = 104,
        cross_device_link = 18,
        destination_address_required = 89,
        device_or_resource_busy = 16,
        directory_not_empty = 39,
        executable_format_error = 8,
        file_exists = 17,
        file_too_large = 27,
        filename_too_long = 36,
        function_not_supported = 38,
        host_unreachable = 113,
        identifier_removed = 43,
        illegal_byte_sequence = 84,
        inappropriate_io_control_operation = 25,
        interrupted = 4,
        invalid_argument = 22,
        invalid_seek = 29,
        io_error = 5,
        is_a_directory = 21,
        message_size = 90,
        network_down = 100,
        network_reset = 102,
        network_unreachable = 101,
        no_buffer_space = 105,
        no_child_process = 10,
        no_link = 67,
        no_lock_available = 37,
        no_message_available = 61,
        no_message = 42,
        no_protocol_option = 92,
        no_space_on_device = 28,
        no_stream_resources = 63,
        no_such_device_or_address = 6,
        no_such_device = 19,
        no_such_file_or_directory = 2,
        no_such_process = 3,
        not_a_directory = 20,
        not_a_socket = 88,
        not_a_stream = 60,
        not_connected = 107,
        not_enough_memory = 12,
        not_supported = 95,
        operation_canceled = 125,
        operation_in_progress = 115,
        operation_not_permitted = 1,
        operation_not_supported = 95,
        operation_would_block = 11,
        owner_dead = 130,
        permission_denied = 13,
        protocol_error = 71,
        protocol_not_supported = 93,
        read_only_file_system = 30,
        resource_deadlock_would_occur = 35,
        resource_unavailable_try_again = 11,
        result_out_of_range = 34,
        state_not_recoverable = 131,
        stream_timeout = 62,
        text_file_busy = 26,
        timed_out = 110,
        too_many_files_open_in_system = 23,
        too_many_files_open = 24,
        too_many_links = 31,
        too_many_symbolic_link_levels = 40,
        value_too_large = 75,
        wrong_protocol_type = 91
      };

    }






    template<> struct is_error_condition_enum<errc::errc_t>
      { static const bool value = true; };
# 182 "/usr/include/boost/system/error_code.hpp" 3 4
    class error_category : public noncopyable
    {
    public:
      virtual ~error_category(){}

      virtual const char * name() const = 0;
      virtual std::string message( int ev ) const = 0;
      virtual error_condition default_error_condition( int ev ) const;
      virtual bool equivalent( int code,
                                           const error_condition & condition ) const;
      virtual bool equivalent( const error_code & code,
                                           int condition ) const;

      bool operator==(const error_category & rhs) const { return this == &rhs; }
      bool operator!=(const error_category & rhs) const { return this != &rhs; }
      bool operator<( const error_category & rhs ) const
      {
        return std::less<const error_category*>()( this, &rhs );
      }
    };



    const error_category & system_category();
    const error_category & generic_category();
# 223 "/usr/include/boost/system/error_code.hpp" 3 4
    class error_condition
    {
    public:


      error_condition() : m_val(0), m_cat(&generic_category()) {}
      error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}

      template <class ErrorConditionEnum>
        error_condition(ErrorConditionEnum e,
          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0)
      {
        *this = make_error_condition(e);
      }



      void assign( int val, const error_category & cat )
      {
        m_val = val;
        m_cat = &cat;
      }

      template<typename ErrorConditionEnum>
        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
          operator=( ErrorConditionEnum val )
      {
        *this = make_error_condition(val);
        return *this;
      }

      void clear()
      {
        m_val = 0;
        m_cat = &generic_category();
      }


      int value() const { return m_val; }
      const error_category & category() const { return *m_cat; }
      std::string message() const { return m_cat->message(value()); }

      typedef void (*unspecified_bool_type)();
      static void unspecified_bool_true() {}

      operator unspecified_bool_type() const
      {
        return m_val == 0 ? 0 : unspecified_bool_true;
      }

      bool operator!() const
      {
        return m_val == 0;
      }




      inline friend bool operator==( const error_condition & lhs,
                                     const error_condition & rhs )
      {
        return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
      }

      inline friend bool operator<( const error_condition & lhs,
                                    const error_condition & rhs )


      {
        return lhs.m_cat < rhs.m_cat
          || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
      }

    private:
      int m_val;
      const error_category * m_cat;

    };
# 310 "/usr/include/boost/system/error_code.hpp" 3 4
    class error_code
    {
    public:


      error_code() : m_val(0), m_cat(&system_category()) {}
      error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}

      template <class ErrorCodeEnum>
        error_code(ErrorCodeEnum e,
          typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
      {
        *this = make_error_code(e);
      }


      void assign( int val, const error_category & cat )
      {
        m_val = val;
        m_cat = &cat;
      }

      template<typename ErrorCodeEnum>
        typename boost::enable_if<is_error_code_enum<ErrorCodeEnum>, error_code>::type &
          operator=( ErrorCodeEnum val )
      {
        *this = make_error_code(val);
        return *this;
      }

      void clear()
      {
        m_val = 0;
        m_cat = &system_category();
      }


      int value() const { return m_val; }
      const error_category & category() const { return *m_cat; }
      error_condition default_error_condition() const { return m_cat->default_error_condition(value()); }
      std::string message() const { return m_cat->message(value()); }

      typedef void (*unspecified_bool_type)();
      static void unspecified_bool_true() {}

      operator unspecified_bool_type() const
      {
        return m_val == 0 ? 0 : unspecified_bool_true;
      }

      bool operator!() const
      {
        return m_val == 0;
      }


      inline friend bool operator==( const error_code & lhs,
                                     const error_code & rhs )


      {
        return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
      }

      inline friend bool operator<( const error_code & lhs,
                                    const error_code & rhs )


      {
        return lhs.m_cat < rhs.m_cat
          || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
      }

      private:
      int m_val;
      const error_category * m_cat;

    };
# 398 "/usr/include/boost/system/error_code.hpp" 3 4
  }

  namespace detail { inline system::error_code * throws() { return 0; } }
# 409 "/usr/include/boost/system/error_code.hpp" 3 4
  inline system::error_code & throws()
    { return *detail::throws(); }

  namespace system
  {


    inline bool operator!=( const error_code & lhs,
                            const error_code & rhs )
    {
      return !(lhs == rhs);
    }

    inline bool operator!=( const error_condition & lhs,
                            const error_condition & rhs )
    {
      return !(lhs == rhs);
    }

    inline bool operator==( const error_code & code,
                            const error_condition & condition )
    {
      return code.category().equivalent( code.value(), condition )
        || condition.category().equivalent( code, condition.value() );
    }

    inline bool operator!=( const error_code & lhs,
                            const error_condition & rhs )
    {
      return !(lhs == rhs);
    }

    inline bool operator==( const error_condition & condition,
                            const error_code & code )
    {
      return condition.category().equivalent( code, condition.value() )
        || code.category().equivalent( code.value(), condition );
    }

    inline bool operator!=( const error_condition & lhs,
                            const error_code & rhs )
    {
      return !(lhs == rhs);
    }



    template <class charT, class traits>
    inline std::basic_ostream<charT,traits>&
      operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
    {
      os << ec.category().name() << ':' << ec.value();
      return os;
    }

    inline std::size_t hash_value( const error_code & ec )
    {
      return static_cast<std::size_t>(ec.value())
        + reinterpret_cast<std::size_t>(&ec.category());
    }



    namespace errc
    {

      inline error_code make_error_code( errc_t e )
        { return error_code( e, generic_category() ); }


      inline error_condition make_error_condition( errc_t e )
        { return error_condition( e, generic_category() ); }
    }



    inline error_condition error_category::default_error_condition( int ev ) const
    {
      return error_condition( ev, *this );
    }

    inline bool error_category::equivalent( int code,
      const error_condition & condition ) const
    {
      return default_error_condition( code ) == condition;
    }

    inline bool error_category::equivalent( const error_code & code,
      int condition ) const
    {
      return *this == code.category() && code.value() == condition;
    }

  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 506 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 15 "/usr/include/boost/system/system_error.hpp" 2 3 4

namespace boost
{
  namespace system
  {


    class __attribute__((visibility("default"))) system_error : public std::runtime_error


    {
    public:
      system_error( error_code ec )
          : std::runtime_error(""), m_error_code(ec) {}

      system_error( error_code ec, const std::string & what_arg )
          : std::runtime_error(what_arg), m_error_code(ec) {}

      system_error( error_code ec, const char* what_arg )
          : std::runtime_error(what_arg), m_error_code(ec) {}

      system_error( int ev, const error_category & ecat )
          : std::runtime_error(""), m_error_code(ev,ecat) {}

      system_error( int ev, const error_category & ecat,
        const std::string & what_arg )
          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}

      system_error( int ev, const error_category & ecat,
        const char * what_arg )
          : std::runtime_error(what_arg), m_error_code(ev,ecat) {}

      virtual ~system_error() throw() {}

      const error_code & code() const throw() { return m_error_code; }
      const char * what() const throw();

    private:
      error_code m_error_code;
      mutable std::string m_what;
    };



    inline const char * system_error::what() const throw()

    {
      if ( m_what.empty() )
      {
        try
        {
          m_what = this->std::runtime_error::what();
          if ( !m_what.empty() ) m_what += ": ";
          m_what += m_error_code.message();
        }
        catch (...) { return std::runtime_error::what(); }
      }
      return m_what.c_str();
    }

  }
}
# 23 "/usr/include/boost/thread/exceptions.hpp" 2 3 4



# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 27 "/usr/include/boost/thread/exceptions.hpp" 2 3 4

namespace boost
{


    class __attribute__((visibility("default"))) thread_interrupted
    {};


    class __attribute__((visibility("default"))) thread_exception:
        public system::system_error

    {
          typedef system::system_error base_type;
    public:
        thread_exception()
          : base_type(0,system::system_category())
        {}

        thread_exception(int sys_error_code)
          : base_type(sys_error_code, system::system_category())
        {}

        thread_exception( int ev, const char * what_arg )
        : base_type(system::error_code(ev, system::system_category()), what_arg)
        {
        }
        thread_exception( int ev, const std::string & what_arg )
        : base_type(system::error_code(ev, system::system_category()), what_arg)
        {
        }

        ~thread_exception() throw()
        {}


        int native_error() const
        {
            return code().value();
        }

    };

    class __attribute__((visibility("default"))) condition_error:
        public system::system_error

    {
          typedef system::system_error base_type;
    public:
          condition_error()
          : base_type(system::error_code(0, system::system_category()), "Condition error")
          {}
          condition_error( int ev )
          : base_type(system::error_code(ev, system::system_category()), "Condition error")
          {
          }
          condition_error( int ev, const char * what_arg )
          : base_type(system::error_code(ev, system::system_category()), what_arg)
          {
          }
          condition_error( int ev, const std::string & what_arg )
          : base_type(system::error_code(ev, system::system_category()), what_arg)
          {
          }
    };


    class __attribute__((visibility("default"))) lock_error:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
        lock_error()
        : base_type(0, "boost::lock_error")
        {}

        lock_error( int ev )
        : base_type(ev, "boost::lock_error")
        {
        }
        lock_error( int ev, const char * what_arg )
        : base_type(ev, what_arg)
        {
        }
        lock_error( int ev, const std::string & what_arg )
        : base_type(ev, what_arg)
        {
        }

        ~lock_error() throw()
        {}

    };

    class __attribute__((visibility("default"))) thread_resource_error:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
          thread_resource_error()
          : base_type(system::errc::resource_unavailable_try_again, "boost::thread_resource_error")
          {}

          thread_resource_error( int ev )
          : base_type(ev, "boost::thread_resource_error")
          {
          }
          thread_resource_error( int ev, const char * what_arg )
          : base_type(ev, what_arg)
          {
          }
          thread_resource_error( int ev, const std::string & what_arg )
          : base_type(ev, what_arg)
          {
          }


        ~thread_resource_error() throw()
        {}

    };

    class __attribute__((visibility("default"))) unsupported_thread_option:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
          unsupported_thread_option()
          : base_type(system::errc::invalid_argument, "boost::unsupported_thread_option")
          {}

          unsupported_thread_option( int ev )
          : base_type(ev, "boost::unsupported_thread_option")
          {
          }
          unsupported_thread_option( int ev, const char * what_arg )
          : base_type(ev, what_arg)
          {
          }
          unsupported_thread_option( int ev, const std::string & what_arg )
          : base_type(ev, what_arg)
          {
          }

    };

    class __attribute__((visibility("default"))) invalid_thread_argument:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
        invalid_thread_argument()
        : base_type(system::errc::invalid_argument, "boost::invalid_thread_argument")
        {}

        invalid_thread_argument( int ev )
        : base_type(ev, "boost::invalid_thread_argument")
        {
        }
        invalid_thread_argument( int ev, const char * what_arg )
        : base_type(ev, what_arg)
        {
        }
        invalid_thread_argument( int ev, const std::string & what_arg )
        : base_type(ev, what_arg)
        {
        }

    };

    class __attribute__((visibility("default"))) thread_permission_error:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
          thread_permission_error()
          : base_type(system::errc::permission_denied, "boost::thread_permission_error")
          {}

          thread_permission_error( int ev )
          : base_type(ev, "boost::thread_permission_error")
          {
          }
          thread_permission_error( int ev, const char * what_arg )
          : base_type(ev, what_arg)
          {
          }
          thread_permission_error( int ev, const std::string & what_arg )
          : base_type(ev, what_arg)
          {
          }

    };

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 224 "/usr/include/boost/thread/exceptions.hpp" 2 3 4
# 11 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/thread/lock_guard.hpp" 1 3 4
# 11 "/usr/include/boost/thread/lock_guard.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/delete.hpp" 1 3 4
# 12 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
# 1 "/usr/include/boost/thread/detail/move.hpp" 1 3 4
# 14 "/usr/include/boost/thread/detail/move.hpp" 3 4
# 1 "/usr/include/boost/type_traits/remove_reference.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/remove_reference.hpp" 2 3 4

namespace boost {



namespace detail{




template <class T>
struct remove_rvalue_ref
{
   typedef T type;
};
# 45 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
}

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; };
# 66 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 69 "/usr/include/boost/type_traits/remove_reference.hpp" 2 3 4
# 15 "/usr/include/boost/thread/detail/move.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/decay.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/decay.hpp" 3 4
# 1 "/usr/include/boost/type_traits/remove_bounds.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/remove_bounds.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 14 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4







# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4



namespace boost {

template< typename T > struct remove_bounds { public: typedef T type; };


template< typename T, std::size_t N > struct remove_bounds<T[N]> { public: typedef T type; };
template< typename T, std::size_t N > struct remove_bounds<T const[N]> { public: typedef T const type; };
template< typename T, std::size_t N > struct remove_bounds<T volatile[N]> { public: typedef T volatile type; };
template< typename T, std::size_t N > struct remove_bounds<T const volatile[N]> { public: typedef T const volatile type; };

template< typename T > struct remove_bounds<T[]> { public: typedef T type; };
template< typename T > struct remove_bounds<T const[]> { public: typedef T const type; };
template< typename T > struct remove_bounds<T volatile[]> { public: typedef T volatile type; };
template< typename T > struct remove_bounds<T const volatile[]> { public: typedef T const volatile type; };



}



# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 47 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_pointer.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4

namespace boost {

namespace detail {
# 55 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
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; };

}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 71 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/decay.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/eval_if.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/eval_if.hpp" 3 4
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> { }; }

}}
# 19 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/identity.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/identity.hpp" 3 4
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> { }; }

}}
# 20 "/usr/include/boost/type_traits/decay.hpp" 2 3 4

namespace boost
{

    template< class T >
    struct decay
    {
    private:
        typedef typename remove_reference<T>::type Ty;
    public:
        typedef typename mpl::eval_if<
            is_array<Ty>,
            mpl::identity<typename remove_bounds<Ty>::type*>,
            typename mpl::eval_if<
                is_function<Ty>,
                add_pointer<Ty>,
                mpl::identity<Ty>
            >
        >::type type;
    };

}
# 17 "/usr/include/boost/thread/detail/move.hpp" 2 3 4



# 1 "/usr/include/boost/move/utility.hpp" 1 3 4
# 17 "/usr/include/boost/move/utility.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/move/utility.hpp" 2 3 4
# 1 "/usr/include/boost/move/core.hpp" 1 3 4
# 19 "/usr/include/boost/move/core.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 20 "/usr/include/boost/move/core.hpp" 2 3 4



# 1 "/usr/include/boost/move/detail/meta_utils.hpp" 1 3 4
# 17 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4



namespace boost {
namespace move_detail {


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, typename T2, typename T3>
struct if_
{
   typedef typename if_c<0 != T1::value, T2, T3>::type type;
};


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 <class Cond, class T = void>
struct disable_if : public enable_if_c<!Cond::value, T> {};


template<class T, T v>
struct integral_constant
{
   static const T value = v;
   typedef T value_type;
   typedef integral_constant<T, v> type;
};


template <class T>
struct identity
{
   typedef T type;
};


template <class T, class U>
class is_convertible
{
   typedef char true_t;
   class false_t { char dummy[2]; };
   static true_t dispatch(U);
   static false_t dispatch(...);
   static T &trigger();
   public:
   enum { value = sizeof(dispatch(trigger())) == sizeof(true_t) };
};


template <typename Condition1, typename Condition2, typename Condition3 = integral_constant<bool, true> >
struct and_
   : public integral_constant<bool, Condition1::value && Condition2::value && Condition3::value>
{};

template <typename Boolean>
struct not_
   : public integral_constant<bool, !Boolean::value>
{};


template<class T>
struct is_lvalue_reference
   : public integral_constant<bool, false>
{};

template<class T>
struct is_lvalue_reference<T&>
   : public integral_constant<bool, true>
{};

template<class T>
struct is_class_or_union
{
   struct twochar { char _[2]; };
   template <class U>
   static char is_class_or_union_tester(void(U::*)(void));
   template <class U>
   static twochar is_class_or_union_tester(...);
   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
};

struct empty{};


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>
inline T * addressof( T & v )
{
   return ::boost::move_detail::addressof_impl<T>::f
      ( ::boost::move_detail::addr_impl_ref<T>( v ), 0 );
}

}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 157 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
# 24 "/usr/include/boost/move/core.hpp" 2 3 4
# 32 "/usr/include/boost/move/core.hpp" 3 4
   namespace boost {






   template <class T>
   class rv
      : public ::boost::move_detail::if_c
         < ::boost::move_detail::is_class_or_union<T>::value
         , T
         , ::boost::move_detail::empty
         >::type
   {
      rv();
      ~rv();
      rv(rv const&);
      void operator=(rv const&);
   } __attribute__((__may_alias__));
# 60 "/usr/include/boost/move/core.hpp" 3 4
   namespace move_detail {

   template <class T>
   struct is_rv
      : ::boost::move_detail::integral_constant<bool, false>
   {};

   template <class T>
   struct is_rv< rv<T> >
      : ::boost::move_detail::integral_constant<bool, true>
   {};

   template <class T>
   struct is_rv< const rv<T> >
      : ::boost::move_detail::integral_constant<bool, true>
   {};

   }






   template<class T>
   struct has_move_emulation_enabled
      : ::boost::move_detail::is_convertible< T, ::boost::rv<T>& >
   {};

   template<class T>
   struct has_move_emulation_enabled<T&>
      : ::boost::move_detail::integral_constant<bool, false>
   {};

   template<class T>
   struct has_move_emulation_enabled< ::boost::rv<T> >
      : ::boost::move_detail::integral_constant<bool, false>
   {};

   }
# 315 "/usr/include/boost/move/core.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 316 "/usr/include/boost/move/core.hpp" 2 3 4
# 19 "/usr/include/boost/move/utility.hpp" 2 3 4




   namespace boost {

   template<class T>
   struct enable_move_utility_emulation
   {
      static const bool value = true;
   };







   template <class T>
   inline typename ::boost::move_detail::enable_if_c
      < enable_move_utility_emulation<T>::value && !has_move_emulation_enabled<T>::value, T&>::type
         move(T& x)
   {
      return x;
   }

   template <class T>
   inline typename ::boost::move_detail::enable_if_c
      < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value, rv<T>&>::type
         move(T& x)
   {
      return *static_cast<rv<T>* >(::boost::move_detail::addressof(x));
   }

   template <class T>
   inline typename ::boost::move_detail::enable_if_c
      < enable_move_utility_emulation<T>::value && has_move_emulation_enabled<T>::value, rv<T>&>::type
         move(rv<T>& x)
   {
      return x;
   }







   template <class T>
   inline typename ::boost::move_detail::enable_if_c
      < enable_move_utility_emulation<T>::value && ::boost::move_detail::is_rv<T>::value, T &>::type
         forward(const typename ::boost::move_detail::identity<T>::type &x)
   {
      return const_cast<T&>(x);
   }

   template <class T>
   inline typename ::boost::move_detail::enable_if_c
      < enable_move_utility_emulation<T>::value && !::boost::move_detail::is_rv<T>::value, const T &>::type
      forward(const typename ::boost::move_detail::identity<T>::type &x)
   {
      return x;
   }

   }
# 192 "/usr/include/boost/move/utility.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 193 "/usr/include/boost/move/utility.hpp" 2 3 4
# 21 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 22 "/usr/include/boost/thread/detail/move.hpp" 2 3 4

namespace boost
{

    namespace detail
    {
      template <typename T>
      struct enable_move_utility_emulation_dummy_specialization;
        template<typename T>
        struct thread_move_t
        {
            T& t;
            explicit thread_move_t(T& t_):
                t(t_)
            {}

            T& operator*() const
            {
                return t;
            }

            T* operator->() const
            {
                return &t;
            }
        private:
            void operator=(thread_move_t&);
        };
    }




    template<typename T>
    typename enable_if<boost::is_convertible<T&,boost::detail::thread_move_t<T> >, boost::detail::thread_move_t<T> >::type move(T& t)
    {
        return boost::detail::thread_move_t<T>(t);
    }


    template<typename T>
    boost::detail::thread_move_t<T> move(boost::detail::thread_move_t<T> t)
    {
        return t;
    }


}
# 157 "/usr/include/boost/thread/detail/move.hpp" 3 4
namespace boost
{
namespace detail
{
  template <typename T>
  boost::detail::thread_move_t< typename ::boost::remove_cv<typename ::boost::remove_reference<T>::type>::type >
  make_rv_ref(T v)
  {
    return (boost::detail::thread_move_t< typename ::boost::remove_cv<typename ::boost::remove_reference<T>::type>::type >)(v);
  }
# 179 "/usr/include/boost/thread/detail/move.hpp" 3 4
}
}
# 238 "/usr/include/boost/thread/detail/move.hpp" 3 4
namespace boost
{ namespace thread_detail
  {
# 249 "/usr/include/boost/thread/detail/move.hpp" 3 4
  template <class T>
  typename decay<T>::type
  decay_copy(const T & t)
  {
      return boost::forward<T>(t);
  }

  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 260 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
# 13 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
# 1 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 1 3 4
# 14 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 15 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4

namespace boost
{
# 41 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 3 4
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 44 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4
# 14 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
# 1 "/usr/include/boost/thread/lock_options.hpp" 1 3 4
# 10 "/usr/include/boost/thread/lock_options.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 11 "/usr/include/boost/thread/lock_options.hpp" 2 3 4

namespace boost
{
  struct defer_lock_t
  {
  };
  struct try_to_lock_t
  {
  };
  struct adopt_lock_t
  {
  };

  const defer_lock_t defer_lock = {};
  const try_to_lock_t try_to_lock = {};
  const adopt_lock_t adopt_lock = {};

}
# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 30 "/usr/include/boost/thread/lock_options.hpp" 2 3 4
# 15 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4





# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 21 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4

namespace boost
{

  template <typename Mutex>
  class lock_guard
  {
  private:
    Mutex& m;

  public:
    typedef Mutex mutex_type;
    private: lock_guard(lock_guard&); public: private: lock_guard& operator=(lock_guard&); public:

    explicit lock_guard(Mutex& m_) :
      m(m_)
    {
      m.lock();
    }

    lock_guard(Mutex& m_, adopt_lock_t) :
      m(m_)
    {



    }
# 65 "/usr/include/boost/thread/lock_guard.hpp" 3 4
    ~lock_guard()
    {
      m.unlock();
    }
  };
# 84 "/usr/include/boost/thread/lock_guard.hpp" 3 4
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 87 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
# 12 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/thread/lock_types.hpp" 1 3 4
# 14 "/usr/include/boost/thread/lock_types.hpp" 3 4
# 1 "/usr/include/boost/thread/lockable_traits.hpp" 1 3 4
# 12 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 13 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4



# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 17 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4



namespace boost
{
  namespace sync
  {
# 34 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
    namespace detail
    {
# 70 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
      template<typename T, bool=boost::is_class<T>::value> struct has_member_called_lock { static const bool value=false; }; template<typename T> struct has_member_called_lock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int lock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::lock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); }
; template<typename T, bool=boost::is_class<T>::value> struct has_member_called_unlock { static const bool value=false; }; template<typename T> struct has_member_called_unlock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int unlock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::unlock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); };
      template<typename T, bool=boost::is_class<T>::value> struct has_member_called_try_lock { static const bool value=false; }; template<typename T> struct has_member_called_try_lock<T,true> { typedef char true_type; struct false_type { true_type dummy[2]; }; struct fallback { int try_lock; }; struct derived: T, fallback { derived(); }; template<int fallback::*> struct tester; template<typename U> static false_type has_member(tester<&U::try_lock>*); template<typename U> static true_type has_member(...); static const bool value=sizeof(has_member<derived>(0))==sizeof(true_type); };

      template<typename T,bool=has_member_called_lock<T>::value >
      struct has_member_lock
      {
        static const bool value=false;
      };

      template<typename T>
      struct has_member_lock<T,true>
      {
        typedef char true_type;
        struct false_type
        {
          true_type dummy[2];
        };

        template<typename U,typename V>
        static true_type has_member(V (U::*)());
        template<typename U>
        static false_type has_member(U);

        static const bool value=sizeof(has_member_lock<T>::has_member(&T::lock))==sizeof(true_type)
                                                                                           ;
      };

      template<typename T,bool=has_member_called_unlock<T>::value >
      struct has_member_unlock
      {
        static const bool value=false;
      };

      template<typename T>
      struct has_member_unlock<T,true>
      {
        typedef char true_type;
        struct false_type
        {
          true_type dummy[2];
        };

        template<typename U,typename V>
        static true_type has_member(V (U::*)());
        template<typename U>
        static false_type has_member(U);

        static const bool value=sizeof(has_member_unlock<T>::has_member(&T::unlock))==sizeof(true_type)
                                                                                               ;
      };

      template<typename T,bool=has_member_called_try_lock<T>::value >
      struct has_member_try_lock
      {
        static const bool value=false;
      };

      template<typename T>
      struct has_member_try_lock<T,true>
      {
        typedef char true_type;
        struct false_type
        {
          true_type dummy[2];
        };

        template<typename U>
        static true_type has_member(bool (U::*)());
        template<typename U>
        static false_type has_member(U);

        static const bool value=sizeof(has_member_try_lock<T>::has_member(&T::try_lock))==sizeof(true_type)
                                                                                                   ;
      };

    }

    template<typename T>
    struct is_basic_lockable
    {
      static const bool value = detail::has_member_lock<T>::value && detail::has_member_unlock<T>::value
                                              ;
    };
    template<typename T>
    struct is_lockable
    {
      static const bool value = is_basic_lockable<T>::value && detail::has_member_try_lock<T>::value

                                                ;
    };
# 175 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
    template<typename T>
    struct is_recursive_mutex_sur_parolle
    {
      static const bool value = false;
    };
    template<typename T>
    struct is_recursive_basic_lockable
    {
      static const bool value = is_basic_lockable<T>::value && is_recursive_mutex_sur_parolle<T>::value
                                                   ;
    };
    template<typename T>
    struct is_recursive_lockable
    {
      static const bool value = is_lockable<T>::value && is_recursive_mutex_sur_parolle<T>::value
                                                   ;
    };
  }
  template<typename T>
  struct is_mutex_type
  {
    static const bool value = sync::is_lockable<T>::value;
  };

}
# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 201 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4
# 15 "/usr/include/boost/thread/lock_types.hpp" 2 3 4





# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 21 "/usr/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/usr/include/boost/chrono/time_point.hpp" 1 3 4
# 38 "/usr/include/boost/chrono/time_point.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 39 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
# 48 "/usr/include/boost/chrono/time_point.hpp" 3 4
namespace boost {
namespace chrono {

  template <class Clock, class Duration = typename Clock::duration>
    class time_point;


}




template <class Clock, class Duration1, class Duration2>
  struct common_type<chrono::time_point<Clock, Duration1>,
                     chrono::time_point<Clock, Duration2> >;







template <class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>,
                   chrono::time_point<Clock, Duration2> >
{
  typedef chrono::time_point<Clock,
    typename common_type<Duration1, Duration2>::type> type;
};



namespace chrono {


    template <class Clock, class Duration1, class Rep2, class Period2>
    inline
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator+(
            const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Clock, class Duration2>
    inline
    time_point<Clock,
        typename common_type<duration<Rep1, Period1>, Duration2>::type>
    operator+(
            const duration<Rep1, Period1>& lhs,
            const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Rep2, class Period2>
    inline
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator-(
            const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline
    typename common_type<Duration1, Duration2>::type
    operator-(
            const time_point<Clock, Duration1>& lhs,
            const time_point<Clock,
            Duration2>& rhs);


    template <class Clock, class Duration1, class Duration2>
    inline
    bool operator==(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline
    bool operator!=(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline
    bool operator< (
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline
    bool operator<=(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline
    bool operator> (
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline
    bool operator>=(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);


    template <class ToDuration, class Clock, class Duration>
    inline
    time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);







    template <class Clock, class Duration>
    class time_point
    {
        static char boost_chrono_test_159[(boost::chrono::detail::is_duration<Duration>::value)?1:-1]
                                                                                                                 ;
    public:
        typedef Clock clock;
        typedef Duration duration;
        typedef typename duration::rep rep;
        typedef typename duration::period period;
        typedef Duration difference_type;

    private:
        duration d_;

    public:
       
        time_point() : d_(duration::zero())
        {}
        explicit time_point(const duration& d)
            : d_(d)
        {}


        template <class Duration2>
       
        time_point(const time_point<clock, Duration2>& t
                , typename boost::enable_if
                <
                    boost::is_convertible<Duration2, duration>
                >::type* = 0
        )
            : d_(t.time_since_epoch())
        {
        }


       
        duration time_since_epoch() const
        {
            return d_;
        }
# 215 "/usr/include/boost/chrono/time_point.hpp" 3 4
        time_point& operator+=(const duration& d) {d_ += d; return *this;}
        time_point& operator-=(const duration& d) {d_ -= d; return *this;}



        static time_point
        min ()
        {
            return time_point((duration::min)());
        }
        static time_point
        max ()
        {
            return time_point((duration::max)());
        }
    };







    template <class Clock, class Duration1, class Rep2, class Period2>
    inline
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator+(const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs)
    {
      typedef typename common_type<Duration1, duration<Rep2, Period2> >::type CDuration;
      typedef time_point<
          Clock,
          CDuration
      > TimeResult;
        return TimeResult(lhs.time_since_epoch() + CDuration(rhs));
    }



    template <class Rep1, class Period1, class Clock, class Duration2>
    inline
    time_point<Clock,
        typename common_type<duration<Rep1, Period1>, Duration2>::type>
    operator+(const duration<Rep1, Period1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return rhs + lhs;
    }



    template <class Clock, class Duration1, class Rep2, class Period2>
    inline
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator-(const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs)
    {
        return lhs + (-rhs);
    }



    template <class Clock, class Duration1, class Duration2>
    inline
    typename common_type<Duration1, Duration2>::type
    operator-(const time_point<Clock, Duration1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return lhs.time_since_epoch() - rhs.time_since_epoch();
    }







    template <class Clock, class Duration1, class Duration2>
    inline
    bool
    operator==(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return lhs.time_since_epoch() == rhs.time_since_epoch();
    }



    template <class Clock, class Duration1, class Duration2>
    inline
    bool
    operator!=(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return !(lhs == rhs);
    }



    template <class Clock, class Duration1, class Duration2>
    inline
    bool
    operator<(const time_point<Clock, Duration1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return lhs.time_since_epoch() < rhs.time_since_epoch();
    }



    template <class Clock, class Duration1, class Duration2>
    inline
    bool
    operator>(const time_point<Clock, Duration1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return rhs < lhs;
    }



    template <class Clock, class Duration1, class Duration2>
    inline
    bool
    operator<=(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return !(rhs < lhs);
    }



    template <class Clock, class Duration1, class Duration2>
    inline
    bool
    operator>=(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return !(lhs < rhs);
    }





    template <class ToDuration, class Clock, class Duration>
    inline
    time_point<Clock, ToDuration>
    time_point_cast(const time_point<Clock, Duration>& t)
    {
        return time_point<Clock, ToDuration>(
                duration_cast<ToDuration>(t.time_since_epoch()));
    }

}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 377 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
# 23 "/usr/include/boost/thread/lock_types.hpp" 2 3 4




# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/usr/include/boost/thread/lock_types.hpp" 2 3 4

namespace boost
{
  struct xtime;

  template <typename Mutex>
  class shared_lock;

  template <typename Mutex>
  class upgrade_lock;

  template <typename Mutex>
  class unique_lock;

  namespace detail
  {
    template <typename Mutex>
    class try_lock_wrapper;
  }
# 98 "/usr/include/boost/thread/lock_types.hpp" 3 4
  template <typename Mutex>
  class unique_lock
  {
  private:
    Mutex* m;
    bool is_locked;

  private:
    explicit unique_lock(upgrade_lock<Mutex>&);
    unique_lock& operator=(upgrade_lock<Mutex>& other);
  public:
    typedef Mutex mutex_type;
    private: unique_lock(unique_lock&); public: private: unique_lock& operator=(unique_lock&); public: operator ::boost::detail::thread_move_t<unique_lock>() { return move(); } ::boost::detail::thread_move_t<unique_lock> move() { ::boost::detail::thread_move_t<unique_lock> x(*this); return x; }






    unique_lock() :
    m(0),is_locked(false)
    {}

    explicit unique_lock(Mutex& m_) :
      m(&m_), is_locked(false)
    {
      lock();
    }
    unique_lock(Mutex& m_, adopt_lock_t) :
      m(&m_), is_locked(true)
    {



    }
    unique_lock(Mutex& m_, defer_lock_t):
    m(&m_),is_locked(false)
    {}
    unique_lock(Mutex& m_, try_to_lock_t) :
      m(&m_), is_locked(false)
    {
      try_lock();
    }

    template<typename TimeDuration>
    unique_lock(Mutex& m_,TimeDuration const& target_time):
    m(&m_),is_locked(false)
    {
      timed_lock(target_time);
    }
    unique_lock(Mutex& m_,system_time const& target_time):
    m(&m_),is_locked(false)
    {
      timed_lock(target_time);
    }


    template <class Clock, class Duration>
    unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
    : m(&mtx), is_locked(mtx.try_lock_until(t))
    {
    }
    template <class Rep, class Period>
    unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
    : m(&mtx), is_locked(mtx.try_lock_for(d))
    {
    }


    unique_lock(boost::detail::thread_move_t< unique_lock > other) :
    m((*other).m),is_locked((*other).is_locked)
    {
      (*other).is_locked=false;
      (*other).m=0;
    }

    unique_lock(boost::detail::thread_move_t< upgrade_lock<Mutex> > other);


    unique_lock& operator=(boost::detail::thread_move_t< upgrade_lock<Mutex> > other)
    {
      unique_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }


    unique_lock& operator=(boost::detail::thread_move_t< unique_lock > other)
    {
      unique_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }
# 202 "/usr/include/boost/thread/lock_types.hpp" 3 4
    unique_lock(boost::detail::thread_move_t< upgrade_lock<mutex_type> > ul, try_to_lock_t)
    : m(0),is_locked(false)
    {
      if ((*ul).owns_lock())
      {
        if ((*ul).mutex()->try_unlock_upgrade_and_lock())
        {
          m = (*ul).release();
          is_locked = true;
        }
      }
      else
      {
        m = (*ul).release();
      }
    }


    template <class Clock, class Duration>
    unique_lock(boost::detail::thread_move_t< upgrade_lock<mutex_type> > ul,
        const chrono::time_point<Clock, Duration>& abs_time)
    : m(0),is_locked(false)
    {
      if ((*ul).owns_lock())
      {
        if ((*ul).mutex()->try_unlock_upgrade_and_lock_until(abs_time))
        {
          m = (*ul).release();
          is_locked = true;
        }
      }
      else
      {
        m = (*ul).release();
      }
    }

    template <class Rep, class Period>
    unique_lock(boost::detail::thread_move_t< upgrade_lock<mutex_type> > ul,
        const chrono::duration<Rep, Period>& rel_time)
    : m(0),is_locked(false)
    {
      if ((*ul).owns_lock())
      {
        if ((*ul).mutex()->try_unlock_upgrade_and_lock_for(rel_time))
        {
          m = (*ul).release();
          is_locked = true;
        }
      }
      else
      {
        m = (*ul).release();
      }
    }
# 319 "/usr/include/boost/thread/lock_types.hpp" 3 4
    void swap(unique_lock& other)
    {
      std::swap(m,other.m);
      std::swap(is_locked,other.is_locked);
    }

    ~unique_lock()
    {
      if (owns_lock())
      {
        m->unlock();
      }
    }
    void lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      m->lock();
      is_locked = true;
    }
    bool try_lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      is_locked = m->try_lock();
      return is_locked;
    }

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const& relative_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      is_locked=m->timed_lock(relative_time);
      return is_locked;
    }

    bool timed_lock(::boost::system_time const& absolute_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      is_locked=m->timed_lock(absolute_time);
      return is_locked;
    }
    bool timed_lock(::boost::xtime const& absolute_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      is_locked=m->timed_lock(absolute_time);
      return is_locked;
    }



    template <class Rep, class Period>
    bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      is_locked=m->try_lock_for(rel_time);
      return is_locked;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost unique_lock owns already the mutex"));
      }
      is_locked=m->try_lock_until(abs_time);
      return is_locked;
    }


    void unlock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock has no mutex"));
      }
      if (!owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost unique_lock doesn't own the mutex"));
      }
      m->unlock();
      is_locked = false;
    }


    typedef void (unique_lock::*bool_type)();
    operator bool_type() const
    {
      return is_locked?&unique_lock::lock:0;
    }
    bool operator!() const
    {
      return !owns_lock();
    }






    bool owns_lock() const
    {
      return is_locked;
    }

    Mutex* mutex() const
    {
      return m;
    }

    Mutex* release()
    {
      Mutex* const res=m;
      m=0;
      is_locked=false;
      return res;
    }

    friend class shared_lock<Mutex> ;
    friend class upgrade_lock<Mutex> ;
  };

  template<typename Mutex>
  void swap(unique_lock<Mutex>& lhs, unique_lock<Mutex>& rhs)
 
  {
    lhs.swap(rhs);
  }

  template <typename Mutex> struct enable_move_utility_emulation< unique_lock<Mutex> > { static const bool value = false; };

  template<typename Mutex>
  class shared_lock
  {
  protected:
    Mutex* m;
    bool is_locked;

  public:
    typedef Mutex mutex_type;
    private: shared_lock(shared_lock&); public: private: shared_lock& operator=(shared_lock&); public: operator ::boost::detail::thread_move_t<shared_lock>() { return move(); } ::boost::detail::thread_move_t<shared_lock> move() { ::boost::detail::thread_move_t<shared_lock> x(*this); return x; }

    shared_lock() :
    m(0),is_locked(false)
    {}

    explicit shared_lock(Mutex& m_):
    m(&m_),is_locked(false)
    {
      lock();
    }
    shared_lock(Mutex& m_,adopt_lock_t):
    m(&m_),is_locked(true)
    {



    }
    shared_lock(Mutex& m_,defer_lock_t) :
    m(&m_),is_locked(false)
    {}
    shared_lock(Mutex& m_,try_to_lock_t):
    m(&m_),is_locked(false)
    {
      try_lock();
    }

    shared_lock(Mutex& m_,system_time const& target_time):
    m(&m_),is_locked(false)
    {
      timed_lock(target_time);
    }


    template <class Clock, class Duration>
    shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
    : m(&mtx), is_locked(mtx.try_lock_shared_until(t))
    {
    }
    template <class Rep, class Period>
    shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
    : m(&mtx), is_locked(mtx.try_lock_shared_for(d))
    {
    }


    shared_lock(boost::detail::thread_move_t< shared_lock<Mutex> > other) :
    m((*other).m),is_locked((*other).is_locked)
    {
      (*other).is_locked=false;
      (*other).m=0;
    }

    shared_lock(boost::detail::thread_move_t< unique_lock<Mutex> > other):
    m((*other).m),is_locked((*other).is_locked)
    {
      if(is_locked)
      {
        m->unlock_and_lock_shared();
      }
      (*other).is_locked=false;
      (*other).m=0;
    }

    shared_lock(boost::detail::thread_move_t< upgrade_lock<Mutex> > other):
    m((*other).m),is_locked((*other).is_locked)
    {
      if(is_locked)
      {
        m->unlock_upgrade_and_lock_shared();
      }
      (*other).is_locked=false;
      (*other).m=0;
    }

    shared_lock& operator=(boost::detail::thread_move_t< shared_lock<Mutex> > other)
    {
      shared_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }

    shared_lock& operator=(boost::detail::thread_move_t< unique_lock<Mutex> > other)
    {
      shared_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }

    shared_lock& operator=(boost::detail::thread_move_t< upgrade_lock<Mutex> > other)
    {
      shared_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }


    void swap(shared_lock& other)
    {
      std::swap(m,other.m);
      std::swap(is_locked,other.is_locked);
    }

    Mutex* mutex() const
    {
      return m;
    }

    Mutex* release()
    {
      Mutex* const res=m;
      m=0;
      is_locked=false;
      return res;
    }

    ~shared_lock()
    {
      if(owns_lock())
      {
        m->unlock_shared();
      }
    }
    void lock()
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      m->lock_shared();
      is_locked=true;
    }
    bool try_lock()
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_shared();
      return is_locked;
    }

    bool timed_lock(boost::system_time const& target_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->timed_lock_shared(target_time);
      return is_locked;
    }
    template<typename Duration>
    bool timed_lock(Duration const& target_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->timed_lock_shared(target_time);
      return is_locked;
    }


    template <class Rep, class Period>
    bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_shared_for(rel_time);
      return is_locked;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_shared_until(abs_time);
      return is_locked;
    }

    void unlock()
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(!owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock doesn't own the mutex"));
      }
      m->unlock_shared();
      is_locked=false;
    }


    typedef void (shared_lock<Mutex>::*bool_type)();
    operator bool_type() const
    {
      return is_locked?&shared_lock::lock:0;
    }
    bool operator!() const
    {
      return !owns_lock();
    }






    bool owns_lock() const
    {
      return is_locked;
    }

  };

  template <typename Mutex> struct enable_move_utility_emulation< shared_lock<Mutex> > { static const bool value = false; };

  template<typename Mutex>
  void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs)
  {
    lhs.swap(rhs);
  }

  template <typename Mutex>
  class upgrade_lock
  {
  protected:
    Mutex* m;
    bool is_locked;

  public:
    typedef Mutex mutex_type;
    private: upgrade_lock(upgrade_lock&); public: private: upgrade_lock& operator=(upgrade_lock&); public: operator ::boost::detail::thread_move_t<upgrade_lock>() { return move(); } ::boost::detail::thread_move_t<upgrade_lock> move() { ::boost::detail::thread_move_t<upgrade_lock> x(*this); return x; }

    upgrade_lock():
    m(0),is_locked(false)
    {}

    explicit upgrade_lock(Mutex& m_) :
      m(&m_), is_locked(false)
    {
      lock();
    }
    upgrade_lock(Mutex& m_, adopt_lock_t) :
      m(&m_), is_locked(true)
    {



    }
    upgrade_lock(Mutex& m_, defer_lock_t):
    m(&m_),is_locked(false)
    {}
    upgrade_lock(Mutex& m_, try_to_lock_t) :
      m(&m_), is_locked(false)
    {
      try_lock();
    }


    template <class Clock, class Duration>
    upgrade_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
    : m(&mtx), is_locked(mtx.try_lock_upgrade_until(t))
    {
    }
    template <class Rep, class Period>
    upgrade_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
    : m(&mtx), is_locked(mtx.try_lock_upgrade_for(d))
    {
    }


    upgrade_lock(boost::detail::thread_move_t< upgrade_lock<Mutex> > other) :
    m((*other).m),is_locked((*other).is_locked)
    {
      (*other).is_locked=false;
      (*other).m=0;
    }

    upgrade_lock(boost::detail::thread_move_t< unique_lock<Mutex> > other):
    m((*other).m),is_locked((*other).is_locked)
    {
      if(is_locked)
      {
        m->unlock_and_lock_upgrade();
      }
      (*other).is_locked=false;
      (*other).m=0;
    }

    upgrade_lock& operator=(boost::detail::thread_move_t< upgrade_lock<Mutex> > other)
    {
      upgrade_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }


    upgrade_lock& operator=(boost::detail::thread_move_t< unique_lock<Mutex> > other)
    {
      upgrade_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }
# 904 "/usr/include/boost/thread/lock_types.hpp" 3 4
    void swap(upgrade_lock& other)
    {
      std::swap(m,other.m);
      std::swap(is_locked,other.is_locked);
    }
    Mutex* mutex() const
    {
      return m;
    }

    Mutex* release()
    {
      Mutex* const res=m;
      m=0;
      is_locked=false;
      return res;
    }
    ~upgrade_lock()
    {
      if (owns_lock())
      {
        m->unlock_upgrade();
      }
    }
    void lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex"));
      }
      m->lock_upgrade();
      is_locked = true;
    }
    bool try_lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(system::errc::resource_deadlock_would_occur, "boost upgrade_lock owns already the mutex"));
      }
      is_locked = m->try_lock_upgrade();
      return is_locked;
    }
    void unlock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if (!owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(system::errc::operation_not_permitted, "boost upgrade_lock doesn't own the mutex"));
      }
      m->unlock_upgrade();
      is_locked = false;
    }

    template <class Rep, class Period>
    bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_upgrade_for(rel_time);
      return is_locked;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(system::errc::operation_not_permitted, "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(system::errc::resource_deadlock_would_occur, "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_upgrade_until(abs_time);
      return is_locked;
    }


    typedef void (upgrade_lock::*bool_type)();
    operator bool_type() const
    {
      return is_locked?&upgrade_lock::lock:0;
    }
    bool operator!() const
    {
      return !owns_lock();
    }






    bool owns_lock() const
    {
      return is_locked;
    }
    friend class shared_lock<Mutex> ;
    friend class unique_lock<Mutex> ;
  };

  template<typename Mutex>
  void swap(upgrade_lock<Mutex>& lhs, upgrade_lock<Mutex>& rhs)
 
  {
    lhs.swap(rhs);
  }

  template <typename Mutex> struct enable_move_utility_emulation< upgrade_lock<Mutex> > { static const bool value = false; };

  template<typename Mutex>
  unique_lock<Mutex>::unique_lock(boost::detail::thread_move_t< upgrade_lock<Mutex> > other):
  m((*other).m),is_locked((*other).is_locked)
  {
    if(is_locked)
    {
      m->unlock_upgrade_and_lock();
    }
    (*other).release();
  }

  template <class Mutex>
  class upgrade_to_unique_lock
  {
  private:
    upgrade_lock<Mutex>* source;
    unique_lock<Mutex> exclusive;

  public:
    typedef Mutex mutex_type;
    private: upgrade_to_unique_lock(upgrade_to_unique_lock&); public: private: upgrade_to_unique_lock& operator=(upgrade_to_unique_lock&); public: operator ::boost::detail::thread_move_t<upgrade_to_unique_lock>() { return move(); } ::boost::detail::thread_move_t<upgrade_to_unique_lock> move() { ::boost::detail::thread_move_t<upgrade_to_unique_lock> x(*this); return x; }

    explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_) :
      source(&m_), exclusive(::boost::move(*source))
    {
    }
    ~upgrade_to_unique_lock()
    {
      if (source)
      {
        *source = upgrade_lock<Mutex> (::boost::move(exclusive)).move();
      }
    }

    upgrade_to_unique_lock(boost::detail::thread_move_t< upgrade_to_unique_lock<Mutex> > other) :
    source((*other).source),exclusive(::boost::move((*other).exclusive))
    {
      (*other).source=0;
    }

    upgrade_to_unique_lock& operator=(boost::detail::thread_move_t< upgrade_to_unique_lock<Mutex> > other)
    {
      upgrade_to_unique_lock temp(other);
      swap(temp);
      return *this;
    }

    void swap(upgrade_to_unique_lock& other)
    {
      std::swap(source,other.source);
      exclusive.swap(other.exclusive);
    }


    typedef void (upgrade_to_unique_lock::*bool_type)(upgrade_to_unique_lock&);
    operator bool_type() const
    {
      return exclusive.owns_lock()?&upgrade_to_unique_lock::swap:0;
    }
    bool operator!() const
    {
      return !owns_lock();
    }







    bool owns_lock() const
    {
      return exclusive.owns_lock();
    }
  };

template <typename Mutex> struct enable_move_utility_emulation< upgrade_to_unique_lock<Mutex> > { static const bool value = false; };

namespace detail
{
  template<typename Mutex>
  class try_lock_wrapper:
private unique_lock<Mutex>
  {
    typedef unique_lock<Mutex> base;
  public:
    private: try_lock_wrapper(try_lock_wrapper&); public: private: try_lock_wrapper& operator=(try_lock_wrapper&); public: operator ::boost::detail::thread_move_t<try_lock_wrapper>() { return move(); } ::boost::detail::thread_move_t<try_lock_wrapper> move() { ::boost::detail::thread_move_t<try_lock_wrapper> x(*this); return x; }

    try_lock_wrapper()
    {}

    explicit try_lock_wrapper(Mutex& m):
    base(m,try_to_lock)
    {}

    try_lock_wrapper(Mutex& m_,adopt_lock_t):
    base(m_,adopt_lock)
    {



    }
    try_lock_wrapper(Mutex& m_,defer_lock_t):
    base(m_,defer_lock)
    {}
    try_lock_wrapper(Mutex& m_,try_to_lock_t):
    base(m_,try_to_lock)
    {}
# 1155 "/usr/include/boost/thread/lock_types.hpp" 3 4
    try_lock_wrapper(boost::detail::thread_move_t< try_lock_wrapper > other):
    base(boost::detail::thread_move_t< base >(*other))
    {}

    try_lock_wrapper& operator=(boost::detail::thread_move_t< try_lock_wrapper<Mutex> > other)
    {
      try_lock_wrapper temp(other);
      swap(temp);
      return *this;
    }
    void swap(try_lock_wrapper& other)
    {
      base::swap(other);
    }
    void lock()
    {
      base::lock();
    }
    bool try_lock()
    {
      return base::try_lock();
    }
    void unlock()
    {
      base::unlock();
    }
    bool owns_lock() const
    {
      return base::owns_lock();
    }
    Mutex* mutex() const
    {
      return base::mutex();
    }
    Mutex* release()
    {
      return base::release();
    }


    typedef typename base::bool_type bool_type;
    operator bool_type() const
    {
      return base::operator bool_type();
    }
    bool operator!() const
    {
      return !this->owns_lock();
    }






  };

  template<typename Mutex>
  void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
  {
    lhs.swap(rhs);
  }
}
}
# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 1220 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
# 13 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/thread/mutex.hpp" 1 3 4
# 16 "/usr/include/boost/thread/mutex.hpp" 3 4
# 1 "/usr/include/boost/thread/pthread/mutex.hpp" 1 3 4
# 17 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
# 1 "/usr/include/boost/thread/xtime.hpp" 1 3 4
# 14 "/usr/include/boost/thread/xtime.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/thread/xtime.hpp" 2 3 4



# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 19 "/usr/include/boost/thread/xtime.hpp" 2 3 4

namespace boost {

enum xtime_clock_types
{
    TIME_UTC_=1







};

struct xtime
{



    typedef int_fast64_t xtime_sec_t;


    typedef int_fast32_t xtime_nsec_t;

    xtime_sec_t sec;
    xtime_nsec_t nsec;

    operator system_time() const
    {
        return boost::posix_time::from_time_t(0)+
            boost::posix_time::seconds(static_cast<long>(sec))+



        boost::posix_time::microseconds((nsec+500)/1000);

    }

};

inline xtime get_xtime(boost::system_time const& abs_time)
{
    xtime res;
    boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);

    res.sec=static_cast<xtime::xtime_sec_t>(time_since_epoch.total_seconds());
    res.nsec=static_cast<xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
    return res;
}

inline int xtime_get(struct xtime* xtp, int clock_type)
{
    if (clock_type == TIME_UTC_)
    {
        *xtp=get_xtime(get_system_time());
        return clock_type;
    }
    return 0;
}


inline int xtime_cmp(const xtime& xt1, const xtime& xt2)
{
    if (xt1.sec == xt2.sec)
        return (int)(xt1.nsec - xt2.nsec);
    else
        return (xt1.sec > xt2.sec) ? 1 : -1;
}

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 92 "/usr/include/boost/thread/xtime.hpp" 2 3 4
# 18 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 19 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/usr/include/errno.h" 1 3 4
# 20 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4



# 1 "/usr/include/boost/chrono/system_clocks.hpp" 1 3 4
# 64 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
# 1 "/usr/include/boost/chrono/detail/system.hpp" 1 3 4
# 11 "/usr/include/boost/chrono/detail/system.hpp" 3 4
# 1 "/usr/include/boost/version.hpp" 1 3 4
# 12 "/usr/include/boost/chrono/detail/system.hpp" 2 3 4
# 65 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/clock_string.hpp" 1 3 4
# 13 "/usr/include/boost/chrono/clock_string.hpp" 3 4
namespace boost
{
  namespace chrono
  {

    template<class Clock, class CharT>
    struct clock_string;

  }

}
# 66 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/ctime" 1 3 4
# 39 "/usr/include/c++/4.8/ctime" 3 4
       
# 40 "/usr/include/c++/4.8/ctime" 3
# 68 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 84 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 85 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 95 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
namespace boost {
namespace chrono {


  class system_clock;

  class steady_clock;



  typedef steady_clock high_resolution_clock;
# 127 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
  class system_clock
  {
  public:
      typedef boost::chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<system_clock> time_point;
      static const bool is_steady = false;

      static time_point now() ;

      static time_point now(system::error_code & ec);


      static std::time_t to_time_t(const time_point& t) ;
      static time_point from_time_t(std::time_t t) ;
  };
# 153 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
  class steady_clock
  {
  public:
      typedef nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<steady_clock> time_point;
      static const bool is_steady = true;

      static time_point now() ;

      static time_point now(system::error_code & ec);

  };
# 176 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
  template<class CharT>
  struct clock_string<system_clock, CharT>
  {
    static std::basic_string<CharT> name()
    {
      static const CharT u[] =
      { 's', 'y', 's', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' };
      static const std::basic_string<CharT> str(u, u + sizeof(u)
          / sizeof(u[0]));
      return str;
    }
    static std::basic_string<CharT> since()
    {
      static const CharT
          u[] =
              { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'J', 'a', 'n', ' ', '1', ',', ' ', '1', '9', '7', '0' };
      static const std::basic_string<CharT> str(u, u + sizeof(u)
          / sizeof(u[0]));
      return str;
    }
  };



  template<class CharT>
  struct clock_string<steady_clock, CharT>
  {
    static std::basic_string<CharT> name()
    {
      static const CharT
          u[] =
              { 's', 't', 'e', 'a', 'd', 'y', '_', 'c', 'l', 'o', 'c', 'k' };
      static const std::basic_string<CharT> str(u, u + sizeof(u)
          / sizeof(u[0]));
      return str;
    }
    static std::basic_string<CharT> since()
    {
      const CharT u[] =
      { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't' };
      const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
      return str;
    }
  };



}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 229 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 24 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/ceil.hpp" 1 3 4
# 16 "/usr/include/boost/chrono/ceil.hpp" 3 4
namespace boost
{
  namespace chrono
  {




    template <class To, class Rep, class Period>
    To ceil(const duration<Rep, Period>& d)
    {
        To t = duration_cast<To>(d);
        if (t < d)
            ++t;
        return t;
    }

  }
}
# 25 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 34 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 35 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4

namespace boost
{
    class mutex
    {
    private:
        pthread_mutex_t m;
    public:
        private: mutex(mutex&); public: private: mutex& operator=(mutex&); public:

        mutex()
        {
            int const res=pthread_mutex_init(&m,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
            }
        }
        ~mutex()
        {
            int ret;
            do
            {
                ret = pthread_mutex_destroy(&m);
            } while (ret == 4);
        }

        void lock()
        {
            int res;
            do
            {
                res = pthread_mutex_lock(&m);
            } while (res == 4);
            if (res)
            {
                boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
            }
        }

        void unlock()
        {
            int res;
            do
            {
              res = pthread_mutex_unlock(&m);
            } while (res == 4);
            if (res)
            {
                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_lock"));
            }
        }

        bool try_lock()
        {
            int res;
            do
            {
                res = pthread_mutex_trylock(&m);
            } while (res == 4);
            if (res==16)
            {
                return false;
            }

            return !res;
        }


        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &m;
        }


        typedef unique_lock<mutex> scoped_lock;
        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;

    };

    typedef mutex try_mutex;

    class timed_mutex
    {
    private:
        pthread_mutex_t m;




    public:
        private: timed_mutex(timed_mutex&); public: private: timed_mutex& operator=(timed_mutex&); public:
        timed_mutex()
        {
            int const res=pthread_mutex_init(&m,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
            }
# 144 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
        }
        ~timed_mutex()
        {
            ((!pthread_mutex_destroy(&m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_destroy(&m)", "/usr/include/boost/thread/pthread/mutex.hpp", 147, __PRETTY_FUNCTION__));



        }


        template<typename TimeDuration>
        bool timed_lock(TimeDuration const & relative_time)
        {
            return timed_lock(get_system_time()+relative_time);
        }
        bool timed_lock(boost::xtime const & absolute_time)
        {
            return timed_lock(system_time(absolute_time));
        }


        void lock()
        {
            int res;
            do
            {
                res = pthread_mutex_lock(&m);
            } while (res == 4);
            if (res)
            {
                boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
            }
        }

        void unlock()
        {
            int res;
            do
            {
              res = pthread_mutex_unlock(&m);
            } while (res == 4);
            if (res)
            {
                boost::throw_exception(lock_error(res,"boost: mutex unlock failed in pthread_mutex_lock"));
            }
        }

        bool try_lock()
        {
          int res;
          do
          {
              res = pthread_mutex_trylock(&m);
          } while (res == 4);
          if (res==16)
          {
              return false;
          }

          return !res;
        }


    private:
        bool do_try_lock_until(struct timespec const &timeout)
        {
          int const res=pthread_mutex_timedlock(&m,&timeout);
          ((!res || res==110) ? static_cast<void> (0) : __assert_fail ("!res || res==110", "/usr/include/boost/thread/pthread/mutex.hpp", 211, __PRETTY_FUNCTION__));
          return !res;
        }
    public:
# 265 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
        bool timed_lock(system_time const & abs_time)
        {
            struct timespec const ts=boost::detail::to_timespec(abs_time);
            return do_try_lock_until(ts);
        }


        template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
        {
          using namespace chrono;
          system_clock::time_point s_now = system_clock::now();
          typename Clock::time_point c_now = Clock::now();
          return try_lock_until(s_now + ceil<nanoseconds>(t - c_now));
        }
        template <class Duration>
        bool try_lock_until(const chrono::time_point<chrono::system_clock, Duration>& t)
        {
          using namespace chrono;
          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
          return try_lock_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
        }
        bool try_lock_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
        {

          chrono::nanoseconds d = tp.time_since_epoch();
          timespec ts = boost::detail::to_timespec(d);
          return do_try_lock_until(ts);
        }



        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &m;
        }


        typedef unique_lock<timed_mutex> scoped_timed_lock;
        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
        typedef scoped_timed_lock scoped_lock;

    };

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 318 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 17 "/usr/include/boost/thread/mutex.hpp" 2 3 4







namespace boost
{
  namespace sync
  {
# 50 "/usr/include/boost/thread/mutex.hpp" 3 4
  }
}
# 14 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 1 3 4
# 9 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 10 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4


# 1 "/usr/include/boost/thread/cv_status.hpp" 1 3 4
# 12 "/usr/include/boost/thread/cv_status.hpp" 3 4
# 1 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 1 3 4
# 130 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 3 4
namespace boost
{







  template <typename EnumType>
  struct underlying_type
  {






    typedef typename EnumType::underlying_type type;
  };




  template <typename EnumType>
  struct native_type
  {




    typedef typename EnumType::enum_type type;
  };
# 172 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 3 4
  template <typename UnderlyingType, typename EnumType>
  UnderlyingType underlying_cast(EnumType v)
  {
    return v.get_underlying_value_();
  }
# 189 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 3 4
  template <typename EnumType>
  inline
  typename EnumType::enum_type native_value(EnumType e)
  {
    return e.native_value_();
  }
# 224 "/usr/include/boost/detail/scoped_enum_emulation.hpp" 3 4
}
# 13 "/usr/include/boost/thread/cv_status.hpp" 2 3 4

namespace boost
{


  struct cv_status { typedef int underlying_type; cv_status() {} explicit cv_status(underlying_type v) : v_(v) {} underlying_type get_underlying_value_() const { return v_; } private: underlying_type v_; typedef cv_status self_type; public: enum enum_type
  {
    no_timeout,
    timeout
  }
  ; cv_status(enum_type v) : v_(v) {} enum_type get_native_value_() const { return enum_type(v_); } operator enum_type() const { return get_native_value_(); } friend bool operator ==(self_type lhs, self_type rhs) { return enum_type(lhs.v_)==enum_type(rhs.v_); } friend bool operator ==(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)==rhs; } friend bool operator ==(enum_type lhs, self_type rhs) { return lhs==enum_type(rhs.v_); } friend bool operator !=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)!=enum_type(rhs.v_); } friend bool operator !=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)!=rhs; } friend bool operator !=(enum_type lhs, self_type rhs) { return lhs!=enum_type(rhs.v_); } friend bool operator <(self_type lhs, self_type rhs) { return enum_type(lhs.v_)<enum_type(rhs.v_); } friend bool operator <(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)<rhs; } friend bool operator <(enum_type lhs, self_type rhs) { return lhs<enum_type(rhs.v_); } friend bool operator <=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)<=enum_type(rhs.v_); } friend bool operator <=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)<=rhs; } friend bool operator <=(enum_type lhs, self_type rhs) { return lhs<=enum_type(rhs.v_); } friend bool operator >(self_type lhs, self_type rhs) { return enum_type(lhs.v_)>enum_type(rhs.v_); } friend bool operator >(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)>rhs; } friend bool operator >(enum_type lhs, self_type rhs) { return lhs>enum_type(rhs.v_); } friend bool operator >=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)>=enum_type(rhs.v_); } friend bool operator >=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)>=rhs; } friend bool operator >=(enum_type lhs, self_type rhs) { return lhs>=enum_type(rhs.v_); } };
}
# 13 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
# 27 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4

namespace boost
{

    class condition_variable
    {
    private:

        pthread_mutex_t internal_mutex;

        pthread_cond_t cond;

    public:


        inline bool do_wait_until(
            unique_lock<mutex>& lock,
            struct timespec const &timeout);

        bool do_wait_for(
            unique_lock<mutex>& lock,
            struct timespec const &timeout)
        {
          return do_wait_until(lock, boost::detail::timespec_plus(timeout, boost::detail::timespec_now()));
        }

    public:
      private: condition_variable(condition_variable&); public: private: condition_variable& operator=(condition_variable&); public:
        condition_variable()
        {

            int const res=pthread_mutex_init(&internal_mutex,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
            }

            int const res2=pthread_cond_init(&cond,__null);
            if(res2)
            {

                ((!pthread_mutex_destroy(&internal_mutex)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_destroy(&internal_mutex)", "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp", 69, __PRETTY_FUNCTION__));

                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable::condition_variable() constructor failed in pthread_cond_init"));
            }
        }
        ~condition_variable()
        {
            int ret;

            do {
              ret = pthread_mutex_destroy(&internal_mutex);
            } while (ret == 4);
            ((!ret) ? static_cast<void> (0) : __assert_fail ("!ret", "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp", 81, __PRETTY_FUNCTION__));

            do {
              ret = pthread_cond_destroy(&cond);
            } while (ret == 4);
            ((!ret) ? static_cast<void> (0) : __assert_fail ("!ret", "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp", 86, __PRETTY_FUNCTION__));
        }

        void wait(unique_lock<mutex>& m);

        template<typename predicate_type>
        void wait(unique_lock<mutex>& m,predicate_type pred)
        {
            while(!pred()) wait(m);
        }



        inline bool timed_wait(
            unique_lock<mutex>& m,
            boost::system_time const& wait_until)
        {




            struct timespec const timeout=detail::to_timespec(wait_until);
            return do_wait_until(m, timeout);

        }
        bool timed_wait(
            unique_lock<mutex>& m,
            xtime const& wait_until)
        {
            return timed_wait(m,system_time(wait_until));
        }

        template<typename duration_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            duration_type const& wait_duration)
        {
            return timed_wait(m,get_system_time()+wait_duration);
        }

        template<typename predicate_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            boost::system_time const& wait_until,predicate_type pred)
        {
            while (!pred())
            {
                if(!timed_wait(m, wait_until))
                    return pred();
            }
            return true;
        }

        template<typename predicate_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            xtime const& wait_until,predicate_type pred)
        {
            return timed_wait(m,system_time(wait_until),pred);
        }

        template<typename duration_type,typename predicate_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            duration_type const& wait_duration,predicate_type pred)
        {
            return timed_wait(m,get_system_time()+wait_duration,pred);
        }




        template <class Duration>
        cv_status
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<chrono::system_clock, Duration>& t)
        {
          using namespace chrono;
          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
          wait_until(lock,
                        nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
          return system_clock::now() < t ? cv_status::no_timeout :
                                             cv_status::timeout;
        }

        template <class Clock, class Duration>
        cv_status
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<Clock, Duration>& t)
        {
          using namespace chrono;
          system_clock::time_point s_now = system_clock::now();
          typename Clock::time_point c_now = Clock::now();
          wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
          return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
        }

        template <class Clock, class Duration, class Predicate>
        bool
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<Clock, Duration>& t,
                Predicate pred)
        {
            while (!pred())
            {
                if (wait_until(lock, t) == cv_status::timeout)
                    return pred();
            }
            return true;
        }


        template <class Rep, class Period>
        cv_status
        wait_for(
                unique_lock<mutex>& lock,
                const chrono::duration<Rep, Period>& d)
        {
          using namespace chrono;
          system_clock::time_point s_now = system_clock::now();
          steady_clock::time_point c_now = steady_clock::now();
          wait_until(lock, s_now + ceil<nanoseconds>(d));
          return steady_clock::now() - c_now < d ? cv_status::no_timeout :
                                                   cv_status::timeout;

        }


        template <class Rep, class Period, class Predicate>
        bool
        wait_for(
                unique_lock<mutex>& lock,
                const chrono::duration<Rep, Period>& d,
                Predicate pred)
        {
          return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));







        }



        typedef pthread_cond_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &cond;
        }

        void notify_one() ;
        void notify_all() ;


        inline cv_status wait_until(
            unique_lock<mutex>& lk,
            chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
        {
            using namespace chrono;
            nanoseconds d = tp.time_since_epoch();
            timespec ts = boost::detail::to_timespec(d);
            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
            else return cv_status::timeout;
        }

    };

    __attribute__((visibility("default"))) void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);

}


# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 265 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
# 15 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4


# 1 "/usr/include/boost/enable_shared_from_this.hpp" 1 3 4
# 16 "/usr/include/boost/enable_shared_from_this.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 1 3 4
# 16 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 1 3 4
# 20 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
namespace boost
{

template<class T> class weak_ptr
{
private:


    typedef weak_ptr<T> this_type;

public:

    typedef typename boost::detail::sp_element< T >::type element_type;

    weak_ptr() : px(0), pn()
    {
    }
# 74 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
    template<class Y>


    weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    : px(r.lock().get()), pn(r.pn)
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }
# 124 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
    template<class Y>


    weak_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 )
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }



    template<class Y>
    weak_ptr & operator=( weak_ptr<Y> const & r )
    {
        boost::detail::sp_assert_convertible< Y, T >();

        px = r.lock().get();
        pn = r.pn;

        return *this;
    }
# 163 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
    template<class Y>
    weak_ptr & operator=( shared_ptr<Y> const & r )
    {
        boost::detail::sp_assert_convertible< Y, T >();

        px = r.px;
        pn = r.pn;

        return *this;
    }



    shared_ptr<T> lock() const
    {
        return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
    }

    long use_count() const
    {
        return pn.use_count();
    }

    bool expired() const
    {
        return pn.use_count() == 0;
    }

    bool _empty() const
    {
        return pn.empty();
    }

    void reset()
    {
        this_type().swap(*this);
    }

    void swap(this_type & other)
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<typename Y>
    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2)
    {
        px = px2;
        pn = r.pn;
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
    {
        return pn < rhs.pn;
    }






private:

    template<class Y> friend class weak_ptr;
    template<class Y> friend class shared_ptr;



    element_type * px;
    boost::detail::weak_count pn;

};

template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b)
{
    return a.owner_before( b );
}

template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b)
{
    a.swap(b);
}

}
# 17 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 19 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4


namespace boost
{

template<class T> class enable_shared_from_this
{
protected:

    enable_shared_from_this()
    {
    }

    enable_shared_from_this(enable_shared_from_this const &)
    {
    }

    enable_shared_from_this & operator=(enable_shared_from_this const &)
    {
        return *this;
    }

    ~enable_shared_from_this()
    {
    }

public:

    shared_ptr<T> shared_from_this()
    {
        shared_ptr<T> p( weak_this_ );
        ((p.get() == this) ? static_cast<void> (0) : __assert_fail ("p.get() == this", "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp", 50, __PRETTY_FUNCTION__));
        return p;
    }

    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p( weak_this_ );
        ((p.get() == this) ? static_cast<void> (0) : __assert_fail ("p.get() == this", "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp", 57, __PRETTY_FUNCTION__));
        return p;
    }

public:


    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
    {
        if( weak_this_.expired() )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
    }

private:

    mutable weak_ptr<T> weak_this_;
};

}
# 17 "/usr/include/boost/enable_shared_from_this.hpp" 2 3 4
# 18 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/optional.hpp" 1 3 4
# 15 "/usr/include/boost/optional.hpp" 3 4
# 1 "/usr/include/boost/optional/optional.hpp" 1 3 4
# 22 "/usr/include/boost/optional/optional.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 23 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/type.hpp" 1 3 4
# 9 "/usr/include/boost/type.hpp" 3 4
namespace boost {



  template <class T>
  struct type {};

}
# 24 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/alignment_of.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 14 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/size_t.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/size_t.hpp" 3 4
# 1 "/usr/include/boost/mpl/size_t_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/size_t_fwd.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 20 "/usr/include/boost/mpl/size_t_fwd.hpp" 2 3 4

namespace mpl_ {

template< std::size_t N > struct size_t;

}
namespace boost { namespace mpl { using ::mpl_::size_t; } }
# 18 "/usr/include/boost/mpl/size_t.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
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;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    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;


}
# 24 "/usr/include/boost/mpl/size_t.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 20 "/usr/include/boost/type_traits/detail/size_t_trait_def.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
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
{
# 71 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
    static const std::size_t value = (::boost::detail::alignment_logic< sizeof(::boost::detail::alignment_of_hack<T>) - sizeof(T), sizeof(T) >::value)



                  ;
# 85 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
};

}

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*>
{
};
# 109 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
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: };


}
# 125 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1 3 4
# 126 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
# 25 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_pod.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_scalar.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_scalar.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_pointer.hpp" 1 3 4
# 24 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
# 28 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
# 24 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
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; };
# 776 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
}
}
# 25 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
# 36 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 37 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4

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: };
# 132 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 135 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
# 29 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
# 39 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 40 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4

namespace boost {
# 50 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
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: };
# 112 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 115 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4
# 25 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
# 41 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 42 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4

namespace boost {





namespace detail {

template< typename T > struct is_pointer_helper
{
    static const bool value = false;
};
# 63 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };



template< typename T >
struct is_pointer_impl
{
# 80 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
    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: };
# 158 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 161 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4

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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 54 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 19 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4







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>
{
};
# 124 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 140 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 19 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 2 3 4

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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 50 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 2 3 4

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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 52 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 2 3 4
# 26 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/type_with_alignment.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/for_each_i.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/list/for_each_i.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/for.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 42 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 1 3 4
# 43 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/list/for_each_i.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/to_list.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/list/transform.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/append.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 24 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 26 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4






namespace boost {



namespace detail {

class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);
typedef int (alignment_dummy::*member_function_ptr)();
# 101 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
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;
};
# 127 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
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;




};
# 161 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
template<std::size_t TAlign, std::size_t Align>
struct is_aligned
{
    static const bool value = (TAlign >= Align) & (TAlign % Align == 0)

         ;
};
# 180 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
}


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); };
}
# 389 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
}





# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 396 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
# 27 "/usr/include/boost/optional/optional.hpp" 2 3 4





# 1 "/usr/include/boost/detail/reference_content.hpp" 1 3 4
# 20 "/usr/include/boost/detail/reference_content.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4

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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 63 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 2 3 4

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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 52 "/usr/include/boost/type_traits/has_nothrow_copy.hpp" 2 3 4
# 21 "/usr/include/boost/detail/reference_content.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/void.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/void.hpp" 3 4
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> { }; }

}}
# 27 "/usr/include/boost/detail/reference_content.hpp" 2 3 4

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;
};
# 109 "/usr/include/boost/detail/reference_content.hpp" 3 4
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_
{
};



}
# 33 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/none.hpp" 1 3 4
# 15 "/usr/include/boost/none.hpp" 3 4
# 1 "/usr/include/boost/none_t.hpp" 1 3 4
# 15 "/usr/include/boost/none_t.hpp" 3 4
namespace boost {

namespace detail { struct none_helper{}; }

typedef int detail::none_helper::*none_t ;

}
# 16 "/usr/include/boost/none.hpp" 2 3 4





namespace boost {

none_t const none = (static_cast<none_t>(0)) ;

}
# 34 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/utility/swap.hpp" 1 3 4
# 25 "/usr/include/boost/utility/swap.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 26 "/usr/include/boost/utility/swap.hpp" 2 3 4

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);
  }
}
# 35 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/utility/addressof.hpp" 1 3 4
# 18 "/usr/include/boost/utility/addressof.hpp" 3 4
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 );


}
# 100 "/usr/include/boost/utility/addressof.hpp" 3 4
}
# 36 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/utility/compare_pointees.hpp" 1 3 4
# 17 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
namespace boost {
# 28 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
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) ; }
} ;
# 51 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
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) ; }
} ;

}
# 37 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 16 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
# 1 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 1 3 4
# 17 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 18 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/punctuation/paren.hpp" 1 3 4
# 21 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/array/elem.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/array/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/array/data.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/array/size.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/slot/slot.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/slot/slot.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/def.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/slot/slot.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4
# 22 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/repetition/enum.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/enum.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
# 24 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
# 25 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1 3 4
# 27 "/usr/include/boost/utility/detail/in_place_factory_prefix.hpp" 2 3 4
# 17 "/usr/include/boost/utility/in_place_factory.hpp" 2 3 4

namespace boost {

class in_place_factory_base {} ;



# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 37 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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;
  }

 
};
# 79 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
inline in_place_factory0 in_place()
{
  return in_place_factory0();
}
# 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/in_place_factory.hpp" 1 3 4
# 35 "/usr/include/boost/utility/in_place_factory.hpp" 3 4
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 );
}
# 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 25 "/usr/include/boost/utility/in_place_factory.hpp" 2 3 4

}

# 1 "/usr/include/boost/utility/detail/in_place_factory_suffix.hpp" 1 3 4
# 29 "/usr/include/boost/utility/in_place_factory.hpp" 2 3 4
# 38 "/usr/include/boost/optional/optional.hpp" 2 3 4

# 1 "/usr/include/boost/optional/optional_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/optional/optional_fwd.hpp" 3 4
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 ;

}
# 40 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 99 "/usr/include/boost/optional/optional.hpp" 3 4
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());
     }
# 433 "/usr/include/boost/optional/optional.hpp" 3 4
    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());
    }
# 558 "/usr/include/boost/optional/optional.hpp" 3 4
    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 { ((this->is_initialized()) ? static_cast<void> (0) : __assert_fail ("this->is_initialized()", "/usr/include/boost/optional/optional.hpp", 630, __PRETTY_FUNCTION__)) ; return this->get_impl(); }
    reference_type get() { ((this->is_initialized()) ? static_cast<void> (0) : __assert_fail ("this->is_initialized()", "/usr/include/boost/optional/optional.hpp", 631, __PRETTY_FUNCTION__)) ; 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 { ((this->is_initialized()) ? static_cast<void> (0) : __assert_fail ("this->is_initialized()", "/usr/include/boost/optional/optional.hpp", 640, __PRETTY_FUNCTION__)) ; return this->get_ptr_impl() ; }
    pointer_type operator->() { ((this->is_initialized()) ? static_cast<void> (0) : __assert_fail ("this->is_initialized()", "/usr/include/boost/optional/optional.hpp", 641, __PRETTY_FUNCTION__)) ; 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() ;
}
# 754 "/usr/include/boost/optional/optional.hpp" 3 4
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 , optional<T> const& y )
{ return equal_pointees(optional<T>() ,y); }

template<class T>
inline
bool operator < ( none_t , 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);
}

}
# 16 "/usr/include/boost/optional.hpp" 2 3 4
# 19 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 20 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4





# 1 "/usr/include/c++/4.8/vector" 1 3 4
# 58 "/usr/include/c++/4.8/vector" 3 4
       
# 59 "/usr/include/c++/4.8/vector" 3





# 1 "/usr/include/c++/4.8/bits/stl_vector.h" 1 3
# 66 "/usr/include/c++/4.8/bits/stl_vector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
        rebind<_Tp>::other _Tp_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
        pointer;

      struct _Vector_impl
      : public _Tp_alloc_type
      {
 pointer _M_start;
 pointer _M_finish;
 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)
 { }
# 101 "/usr/include/c++/4.8/bits/stl_vector.h" 3
 void _M_swap_data(_Vector_impl& __x)
 {
   std::swap(_M_start, __x._M_start);
   std::swap(_M_finish, __x._M_finish);
   std::swap(_M_end_of_storage, __x._M_end_of_storage);
 }
      };

    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()
      { _M_create_storage(__n); }

      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      { _M_create_storage(__n); }
# 159 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      ~_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;

      pointer
      _M_allocate(size_t __n)
      { return __n != 0 ? _M_impl.allocate(__n) : 0; }

      void
      _M_deallocate(pointer __p, size_t __n)
      {
 if (__p)
   _M_impl.deallocate(__p, __n);
      }

    private:
      void
      _M_create_storage(size_t __n)
      {
 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;
      }
    };
# 209 "/usr/include/c++/4.8/bits/stl_vector.h" 3
  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;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;

    public:
      typedef _Tp value_type;
      typedef typename _Base::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::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) { }
# 294 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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); }
# 310 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      vector(const vector& __x)
      : _Base(__x.size(),
        _Alloc_traits::_S_select_on_copy(__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());
      }
# 397 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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());
 }
# 414 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      ~vector()
      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator()); }
# 426 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 478 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 501 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      template<typename _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }
# 529 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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()); }
# 644 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      size_type
      size() const
      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }


      size_type
      max_size() const
      { return _Alloc_traits::max_size(_M_get_Tp_allocator()); }
# 703 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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);
      }
# 724 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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(); }
# 754 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 769 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      reference
      operator[](size_type __n)
      { return *(this->_M_impl._M_start + __n); }
# 784 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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:
# 809 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 827 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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); }
# 876 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      pointer

      data()
      { return std::__addressof(front()); }




      const_pointer

      data() const
      { return std::__addressof(front()); }
# 900 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      push_back(const value_type& __x)
      {
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   {
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
                              __x);
     ++this->_M_impl._M_finish;
   }
 else



   _M_insert_aux(end(), __x);

      }
# 936 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      pop_back()
      {
 --this->_M_impl._M_finish;
 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
      }
# 972 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1022 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      { _M_fill_insert(__position, __n, __x); }
# 1048 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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());
 }
# 1074 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      iterator
      erase(iterator __position);
# 1095 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1107 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      swap(vector& __x)



      {
 this->_M_impl._M_swap_data(__x._M_impl);
 _Alloc_traits::_S_on_swap(_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;
     }
 }
# 1159 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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;
      }
# 1237 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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);
# 1277 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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);
# 1322 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      void
      _M_insert_aux(iterator __position, const value_type& __x);
# 1335 "/usr/include/c++/4.8/bits/stl_vector.h" 3
      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;
      }
# 1388 "/usr/include/c++/4.8/bits/stl_vector.h" 3
    };
# 1401 "/usr/include/c++/4.8/bits/stl_vector.h" 3
  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())); }
# 1418 "/usr/include/c++/4.8/bits/stl_vector.h" 3
  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); }


}
# 65 "/usr/include/c++/4.8/vector" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_bvector.h" 1 3
# 63 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
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; }
  };
# 136 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
  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) { }
# 465 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
      ~_Bvector_base()
      { this->_M_deallocate(); }

    protected:
      _Bvector_impl _M_impl;

      _Bit_type*
      _M_allocate(size_t __n)
      { return _M_impl.allocate(_S_nword(__n)); }

      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);
      }

      static size_t
      _S_nword(size_t __n)
      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
    };


}




namespace std __attribute__ ((__visibility__ ("default")))
{

# 517 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
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::_S_nword;
    using _Base::_M_get_Bit_allocator;

  public:
    vector()
    : _Base() { }

    explicit
    vector(const allocator_type& __a)
    : _Base(__a) { }
# 572 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    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);
    }
# 611 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    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;
    }
# 661 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    void
    assign(size_type __n, const bool& __x)
    { _M_fill_assign(__n, __x); }
# 672 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    template<typename _InputIterator>
      void
      assign(_InputIterator __first, _InputIterator __last)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_assign_dispatch(__first, __last, _Integral());
      }
# 687 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    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()); }
# 737 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    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)
    {
      if (__n > max_size())
 __throw_length_error(("vector::reserve"));
      if (capacity() < __n)
 _M_reallocate(__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;
    }
# 877 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    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 + _S_nword(__n);
      this->_M_impl._M_start = iterator(__q, 0);
      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
    }

    void
    _M_reallocate(size_type __n);
# 977 "/usr/include/c++/4.8/bits/stl_bvector.h" 3
    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; }
  };


}
# 66 "/usr/include/c++/4.8/vector" 2 3



# 1 "/usr/include/c++/4.8/bits/vector.tcc" 1 3
# 59 "/usr/include/c++/4.8/bits/vector.tcc" 3
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;
 }
    }
# 105 "/usr/include/c++/4.8/bits/vector.tcc" 3
  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())
 {
   _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, __x);
   ++this->_M_impl._M_finish;
 }
      else
 {
# 127 "/usr/include/c++/4.8/bits/vector.tcc" 3
     _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;
      _Alloc_traits::destroy(this->_M_impl, 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)
 {
# 184 "/usr/include/c++/4.8/bits/vector.tcc" 3
   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());
   }
      }
# 316 "/usr/include/c++/4.8/bits/vector.tcc" 3
  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)
 {
   _Alloc_traits::construct(this->_M_impl, 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
     {




       _Alloc_traits::construct(this->_M_impl,
                         __new_start + __elems_before,



                                __x);

       __new_finish = 0;

       __new_finish
  = std::__uninitialized_move_if_noexcept_a
  (this->_M_impl._M_start, __position.base(),
   __new_start, _M_get_Tp_allocator());

       ++__new_finish;

       __new_finish
  = std::__uninitialized_move_if_noexcept_a
  (__position.base(), this->_M_impl._M_finish,
   __new_finish, _M_get_Tp_allocator());
     }
          catch(...)
     {
       if (!__new_finish)
  _Alloc_traits::destroy(this->_M_impl,
                         __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;
 }
    }
# 439 "/usr/include/c++/4.8/bits/vector.tcc" 3
  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_if_noexcept_a
      (this->_M_impl._M_start, __position.base(),
       __new_start, _M_get_Tp_allocator());

    __new_finish += __n;

    __new_finish
      = std::__uninitialized_move_if_noexcept_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;
     }
 }
    }
# 591 "/usr/include/c++/4.8/bits/vector.tcc" 3
  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_if_noexcept_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_if_noexcept_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>::
    _M_reallocate(size_type __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 + _S_nword(__n);
    }

  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 + _S_nword(__len);
   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 + _S_nword(__len);
  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 + _S_nword(__len);
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }
# 811 "/usr/include/c++/4.8/bits/vector.tcc" 3

}
# 70 "/usr/include/c++/4.8/vector" 2 3
# 26 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 35 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 36 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4

namespace boost
{
    class thread_attributes {
    public:
        thread_attributes() {
            int res = pthread_attr_init(&val_);
            ((!res && "pthread_attr_init failed") ? static_cast<void> (0) : __assert_fail ("!res && \"pthread_attr_init failed\"", "/usr/include/boost/thread/pthread/thread_data.hpp", 43, __PRETTY_FUNCTION__));
        }
        ~thread_attributes() {
          int res = pthread_attr_destroy(&val_);
          ((!res && "pthread_attr_destroy failed") ? static_cast<void> (0) : __assert_fail ("!res && \"pthread_attr_destroy failed\"", "/usr/include/boost/thread/pthread/thread_data.hpp", 47, __PRETTY_FUNCTION__));
        }

        void set_stack_size(std::size_t size) {
          if (size==0) return;
          std::size_t page_size = getpagesize();

          if (size<16384) size=16384;

          size = ((size+page_size-1)/page_size)*page_size;
          int res = pthread_attr_setstacksize(&val_, size);
          ((!res && "pthread_attr_setstacksize failed") ? static_cast<void> (0) : __assert_fail ("!res && \"pthread_attr_setstacksize failed\"", "/usr/include/boost/thread/pthread/thread_data.hpp", 58, __PRETTY_FUNCTION__));
        }

        std::size_t get_stack_size() const {
            std::size_t size;
            int res = pthread_attr_getstacksize(&val_, &size);
            ((!res && "pthread_attr_getstacksize failed") ? static_cast<void> (0) : __assert_fail ("!res && \"pthread_attr_getstacksize failed\"", "/usr/include/boost/thread/pthread/thread_data.hpp", 64, __PRETTY_FUNCTION__));
            return size;
        }


        typedef pthread_attr_t native_handle_type;
        native_handle_type* native_handle() {
          return &val_;
        }
        const native_handle_type* native_handle() const {
          return &val_;
        }

    private:
        pthread_attr_t val_;
    };

    class thread;

    namespace detail
    {
        struct future_object_base;
        struct tss_cleanup_function;
        struct thread_exit_callback_node;
        struct tss_data_node
        {
            boost::shared_ptr<boost::detail::tss_cleanup_function> func;
            void* value;

            tss_data_node(boost::shared_ptr<boost::detail::tss_cleanup_function> func_,
                          void* value_):
                func(func_),value(value_)
            {}
        };

        struct thread_data_base;
        typedef boost::shared_ptr<thread_data_base> thread_data_ptr;

        struct __attribute__((visibility("default"))) thread_data_base:
            enable_shared_from_this<thread_data_base>
        {
            thread_data_ptr self;
            pthread_t thread_handle;
            boost::mutex data_mutex;
            boost::condition_variable done_condition;
            boost::mutex sleep_mutex;
            boost::condition_variable sleep_condition;
            bool done;
            bool join_started;
            bool joined;
            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
            std::map<void const*,boost::detail::tss_data_node> tss_data;

            pthread_mutex_t* cond_mutex;
            pthread_cond_t* current_cond;
            typedef std::vector<std::pair<condition_variable*, mutex*>

            > notify_list_t;
            notify_list_t notify;

            typedef std::vector<shared_ptr<future_object_base> > async_states_t;
            async_states_t async_states_;





            bool interrupt_enabled;
            bool interrupt_requested;

            thread_data_base():
                done(false),join_started(false),joined(false),
                thread_exit_callbacks(0),
                current_cond(0),
                notify(),
                async_states_()

                , interrupt_enabled(true)
                , interrupt_requested(false)

            {}
            virtual ~thread_data_base();

            typedef pthread_t native_handle_type;

            virtual void run()=0;
            virtual void notify_all_at_thread_exit(condition_variable* cv, mutex* m)
            {
              notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
            }

            void make_ready_at_thread_exit(shared_ptr<future_object_base> as)
            {
              async_states_.push_back(as);
            }

        };

        __attribute__((visibility("default"))) thread_data_base* get_current_thread_data();


        class interruption_checker
        {
            thread_data_base* const thread_info;
            pthread_mutex_t* m;
            bool set;

            void check_for_interruption()
            {

                if(thread_info->interrupt_requested)
                {
                    thread_info->interrupt_requested=false;
                    throw thread_interrupted();
                }

            }

            void operator=(interruption_checker&);
        public:
            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
                thread_info(detail::get_current_thread_data()),m(cond_mutex),
                set(thread_info && thread_info->interrupt_enabled)
            {
                if(set)
                {
                    lock_guard<mutex> guard(thread_info->data_mutex);
                    check_for_interruption();
                    thread_info->cond_mutex=cond_mutex;
                    thread_info->current_cond=cond;
                    ((!pthread_mutex_lock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_lock(m)", "/usr/include/boost/thread/pthread/thread_data.hpp", 194, __PRETTY_FUNCTION__));
                }
                else
                {
                    ((!pthread_mutex_lock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_lock(m)", "/usr/include/boost/thread/pthread/thread_data.hpp", 198, __PRETTY_FUNCTION__));
                }
            }
            ~interruption_checker()
            {
                if(set)
                {
                    ((!pthread_mutex_unlock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_unlock(m)", "/usr/include/boost/thread/pthread/thread_data.hpp", 205, __PRETTY_FUNCTION__));
                    lock_guard<mutex> guard(thread_info->data_mutex);
                    thread_info->cond_mutex=__null;
                    thread_info->current_cond=__null;
                }
                else
                {
                    ((!pthread_mutex_unlock(m)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_unlock(m)", "/usr/include/boost/thread/pthread/thread_data.hpp", 212, __PRETTY_FUNCTION__));
                }
            }
        };

    }

    namespace this_thread
    {
      namespace hiden
      {
        void __attribute__((visibility("default"))) sleep_for(const timespec& ts);
        void __attribute__((visibility("default"))) sleep_until(const timespec& ts);
      }




        inline
        void __attribute__((visibility("default"))) sleep_for(const chrono::nanoseconds& ns)
        {
            return boost::this_thread::hiden::sleep_for(boost::detail::to_timespec(ns));
        }



        void __attribute__((visibility("default"))) yield() ;






        inline void sleep(system_time const& abs_time)
        {
          return boost::this_thread::hiden::sleep_until(boost::detail::to_timespec(abs_time));
        }

        template<typename TimeDuration>
        inline __attribute__((visibility("default"))) void sleep(TimeDuration const& rel_time)
        {
            this_thread::sleep(get_system_time()+rel_time);
        }

    }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 260 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 13 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 21 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 22 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4

namespace boost
{

    namespace this_thread
    {
        void __attribute__((visibility("default"))) interruption_point();
    }


    namespace thread_cv_detail
    {
        template<typename MutexType>
        struct lock_on_exit
        {
            MutexType* m;

            lock_on_exit():
                m(0)
            {}

            void activate(MutexType& m_)
            {
                m_.unlock();
                m=&m_;
            }
            ~lock_on_exit()
            {
                if(m)
                {
                    m->lock();
                }
           }
        };
    }

    inline void condition_variable::wait(unique_lock<mutex>& m)
    {






        int res=0;
        {

            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            guard.activate(m);
            do {
              res = pthread_cond_wait(&cond,&internal_mutex);
            } while (res == 4);







        }

        this_thread::interruption_point();

        if(res)
        {
            boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
        }
    }

    inline bool condition_variable::do_wait_until(
                unique_lock<mutex>& m,
                struct timespec const &timeout)
    {






        thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
        int cond_res;
        {

            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            guard.activate(m);
            cond_res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);





        }

        this_thread::interruption_point();

        if(cond_res==110)
        {
            return false;
        }
        if(cond_res)
        {
            boost::throw_exception(condition_error(cond_res, "boost::condition_variable::do_wait_until failed in pthread_cond_timedwait"));
        }
        return true;
    }

    inline void condition_variable::notify_one()
    {

        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);

        ((!pthread_cond_signal(&cond)) ? static_cast<void> (0) : __assert_fail ("!pthread_cond_signal(&cond)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 134, __PRETTY_FUNCTION__));
    }

    inline void condition_variable::notify_all()
    {

        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);

        ((!pthread_cond_broadcast(&cond)) ? static_cast<void> (0) : __assert_fail ("!pthread_cond_broadcast(&cond)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 142, __PRETTY_FUNCTION__));
    }

    class condition_variable_any
    {
        pthread_mutex_t internal_mutex;
        pthread_cond_t cond;

    public:
        private: condition_variable_any(condition_variable_any&); public: private: condition_variable_any& operator=(condition_variable_any&); public:
        condition_variable_any()
        {
            int const res=pthread_mutex_init(&internal_mutex,__null);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
            }
            int const res2=pthread_cond_init(&cond,__null);
            if(res2)
            {
                ((!pthread_mutex_destroy(&internal_mutex)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_destroy(&internal_mutex)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 162, __PRETTY_FUNCTION__));
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init"));
            }
        }
        ~condition_variable_any()
        {
            ((!pthread_mutex_destroy(&internal_mutex)) ? static_cast<void> (0) : __assert_fail ("!pthread_mutex_destroy(&internal_mutex)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 168, __PRETTY_FUNCTION__));
            ((!pthread_cond_destroy(&cond)) ? static_cast<void> (0) : __assert_fail ("!pthread_cond_destroy(&cond)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 169, __PRETTY_FUNCTION__));
        }

        template<typename lock_type>
        void wait(lock_type& m)
        {
            int res=0;
            {
                thread_cv_detail::lock_on_exit<lock_type> guard;

                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);



                guard.activate(m);
                res=pthread_cond_wait(&cond,&internal_mutex);
            }

            this_thread::interruption_point();

            if(res)
            {
                boost::throw_exception(condition_error(res, "boost::condition_variable_any::wait() failed in pthread_cond_wait"));
            }
        }

        template<typename lock_type,typename predicate_type>
        void wait(lock_type& m,predicate_type pred)
        {
            while(!pred()) wait(m);
        }


        template<typename lock_type>
        bool timed_wait(lock_type& m,boost::system_time const& wait_until)
        {
            struct timespec const timeout=detail::to_timespec(wait_until);
            return do_wait_until(m, timeout);
        }
        template<typename lock_type>
        bool timed_wait(lock_type& m,xtime const& wait_until)
        {
            return timed_wait(m,system_time(wait_until));
        }

        template<typename lock_type,typename duration_type>
        bool timed_wait(lock_type& m,duration_type const& wait_duration)
        {
            return timed_wait(m,get_system_time()+wait_duration);
        }

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& m,boost::system_time const& wait_until,predicate_type pred)
        {
            while (!pred())
            {
                if(!timed_wait(m, wait_until))
                    return pred();
            }
            return true;
        }

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& m,xtime const& wait_until,predicate_type pred)
        {
            return timed_wait(m,system_time(wait_until),pred);
        }

        template<typename lock_type,typename duration_type,typename predicate_type>
        bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
        {
            return timed_wait(m,get_system_time()+wait_duration,pred);
        }


        template <class lock_type,class Duration>
        cv_status
        wait_until(
                lock_type& lock,
                const chrono::time_point<chrono::system_clock, Duration>& t)
        {
          using namespace chrono;
          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
          wait_until(lock,
                        nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
          return system_clock::now() < t ? cv_status::no_timeout :
                                             cv_status::timeout;
        }

        template <class lock_type, class Clock, class Duration>
        cv_status
        wait_until(
                lock_type& lock,
                const chrono::time_point<Clock, Duration>& t)
        {
          using namespace chrono;
          system_clock::time_point s_now = system_clock::now();
          typename Clock::time_point c_now = Clock::now();
          wait_until(lock, s_now + ceil<nanoseconds>(t - c_now));
          return Clock::now() < t ? cv_status::no_timeout : cv_status::timeout;
        }

        template <class lock_type, class Clock, class Duration, class Predicate>
        bool
        wait_until(
                lock_type& lock,
                const chrono::time_point<Clock, Duration>& t,
                Predicate pred)
        {
            while (!pred())
            {
                if (wait_until(lock, t) == cv_status::timeout)
                    return pred();
            }
            return true;
        }


        template <class lock_type, class Rep, class Period>
        cv_status
        wait_for(
                lock_type& lock,
                const chrono::duration<Rep, Period>& d)
        {
          using namespace chrono;
          system_clock::time_point s_now = system_clock::now();
          steady_clock::time_point c_now = steady_clock::now();
          wait_until(lock, s_now + ceil<nanoseconds>(d));
          return steady_clock::now() - c_now < d ? cv_status::no_timeout :
                                                   cv_status::timeout;

        }


        template <class lock_type, class Rep, class Period, class Predicate>
        bool
        wait_for(
                lock_type& lock,
                const chrono::duration<Rep, Period>& d,
                Predicate pred)
        {
          return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));







        }

        template <class lock_type>
        cv_status wait_until(
            lock_type& lk,
            chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp)
        {
            using namespace chrono;
            nanoseconds d = tp.time_since_epoch();
            timespec ts = boost::detail::to_timespec(d);
            if (do_wait_until(lk, ts)) return cv_status::no_timeout;
            else return cv_status::timeout;
        }


        void notify_one()
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            ((!pthread_cond_signal(&cond)) ? static_cast<void> (0) : __assert_fail ("!pthread_cond_signal(&cond)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 336, __PRETTY_FUNCTION__));
        }

        void notify_all()
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            ((!pthread_cond_broadcast(&cond)) ? static_cast<void> (0) : __assert_fail ("!pthread_cond_broadcast(&cond)", "/usr/include/boost/thread/pthread/condition_variable.hpp", 342, __PRETTY_FUNCTION__));
        }
    private:

        template <class lock_type>
        inline bool do_wait_until(
          lock_type& m,
          struct timespec const &timeout)
        {
          int res=0;
          {
              thread_cv_detail::lock_on_exit<lock_type> guard;

              detail::interruption_checker check_for_interruption(&internal_mutex,&cond);



              guard.activate(m);
              res=pthread_cond_timedwait(&cond,&internal_mutex,&timeout);
          }

          this_thread::interruption_point();

          if(res==110)
          {
              return false;
          }
          if(res)
          {
              boost::throw_exception(condition_error(res, "boost::condition_variable_any::do_wait_until() failed in pthread_cond_timedwait"));
          }
          return true;
        }


    };

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 382 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 17 "/usr/include/boost/thread/condition_variable.hpp" 2 3 4
# 22 "./drizzled/common_fwd.h" 2

# 1 "/usr/include/c++/4.8/cstring" 1 3
# 39 "/usr/include/c++/4.8/cstring" 3
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 24 "./drizzled/common_fwd.h" 2
# 1 "./drizzled/visibility.h" 1
# 28 "./drizzled/visibility.h"
       
# 25 "./drizzled/common_fwd.h" 2
# 1 "./drizzled/util/data_ref.h" 1
# 18 "./drizzled/util/data_ref.h"
       

# 1 "/usr/include/c++/4.8/cstddef" 1 3
# 39 "/usr/include/c++/4.8/cstddef" 3
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 21 "./drizzled/util/data_ref.h" 2
# 1 "/usr/include/c++/4.8/cstring" 1 3
# 39 "/usr/include/c++/4.8/cstring" 3
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 22 "./drizzled/util/data_ref.h" 2



template <class T>
class data_ref_basic
{
public:
  data_ref_basic()
  {
    clear();
  }

  template <class U>
  data_ref_basic(const U& c)
  {
    assign(&*c.begin(), &*c.end());
  }

  data_ref_basic(const void* b, const void* e)
  {
    assign(b, e);
  }

  data_ref_basic(const void* b, size_t sz)
  {
    assign(b, sz);
  }

  explicit data_ref_basic(const char* b)
  {
    assign(b, strlen(b));
  }

  void clear()
  {
    begin_ = end_ = reinterpret_cast<T>("");
  }

  void assign(const void* b, const void* e)
  {
    begin_ = reinterpret_cast<T>(b);
    end_ = reinterpret_cast<T>(e);
  }

  void assign(const void* b, size_t sz)
  {
    begin_ = reinterpret_cast<T>(b);
    end_ = begin_ + sz;
  }

  T begin() const
  {
    return begin_;
  }

  T end() const
  {
    return end_;
  }

  T data() const
  {
    return begin();
  }

  size_t size() const
  {
    return end() - begin();
  }

  bool empty() const
  {
    return begin() == end();
  }

  operator std::string() const
  {
    return to_string(*this);
  }
private:
  T begin_;
  T end_;
};

typedef data_ref_basic<const unsigned char*> data_ref;
typedef data_ref_basic<const char*> str_ref;

inline std::ostream& operator<<(std::ostream& os, str_ref v)
{
  return os.write(v.data(), v.size());
}

inline std::string to_string(str_ref v)
{
  return std::string(v.data(), v.size());
}
# 26 "./drizzled/common_fwd.h" 2



namespace drizzled {

namespace catalog
{
  class Instance;

  namespace lock
  {
    class Create;
    class Erase;
  }
}

namespace field
{
  class Epoch;
  class TableShare;
}

namespace generator
{
  class TableDefinitionCache;

  namespace catalog
  {
    class Cache;
    class Instance;
  }
}

namespace internal
{
  struct io_cache_st;
  struct st_my_thread_var;
}

namespace identifier
{
  class Catalog;
  class Schema;
  class Table;
  class User;

  typedef int64_t Session;

  namespace catalog
  {
    typedef std::vector<Catalog> vector;
  }

  namespace schema
  {
    typedef std::vector<Schema> vector;
  }

  namespace table
  {

    typedef std::vector<Table> vector;
  }

  namespace user
  {
    typedef boost::shared_ptr<const User> ptr;
    typedef boost::shared_ptr<User> mptr;
  }
}

namespace item
{
  class Boolean;
  class False;
  class True;
}

namespace memory
{
  class Root;
}

namespace message
{
  class AlterSchemaStatement;
  class AlterTable;
  class CreateSchemaStatement;
  class CreateTableStatement;
  class DeleteData;
  class DeleteHeader;
  class DeleteRecord;
  class DropSchemaStatement;
  class DropTableStatement;
  class InsertData;
  class InsertHeader;
  class InsertRecord;
  class Resultset;
  class Schema;
  class SetVariableStatement;
  class Statement;
  class Table;
  class Transaction;
  class TruncateTableStatement;
  class UpdateData;
  class UpdateHeader;
  class UpdateRecord;
}

namespace module
{
  class Graph;
  class Library;
  class Manifest;
  class Module;
  class option_map;
  class Registry;
  class VertexHandle;
}

namespace plugin
{
  class Catalog;
  class Client;
  class EventData;
  class EventObserver;
  class EventObserverList;
  class Function;
  class Listen;
  class MonitoredInTransaction;
  class NullClient;
  class Scheduler;
  class StorageEngine;
  class TransactionApplier;
  class TransactionReplicator;
  class TransactionalStorageEngine;
  class XaResourceManager;
  class XaStorageEngine;
}

namespace optimizer
{
  class compare_functor;
  class CostVector;
  class Parameter;
  class Position;
  class QuickRange;
  class QuickRangeSelect;
  class RangeParameter;
  class RorScanInfo;
  class SEL_ARG;
  class SEL_IMERGE;
  class SEL_TREE;
  class SqlSelect;
  struct st_qsel_param;
}

namespace session
{
  class State;
  class TableMessages;
  class Times;
  class Transactions;
}

namespace sql
{
  class ResultSet;
}

namespace statement
{
  class Statement;
}

namespace table
{
  class Cache;
  class Concurrent;
  class Placeholder;
  class Singular;

  namespace instance
  {
    class Shared;
  }
}

namespace type
{
  class Decimal;
  class Time;

  typedef int64_t datetime_t;
  typedef int64_t date_t;
  typedef int64_t epoch_t;
  typedef uint32_t usec_t;
}

namespace util
{
  class Storable;
  struct insensitive_equal_to;
  struct insensitive_hash;

  namespace string
  {
    typedef boost::shared_ptr<const std::string> ptr;
    typedef boost::shared_ptr<std::string> mptr;
    typedef std::vector<std::string> vector;
  }
}

typedef struct my_locale_st MY_LOCALE;
typedef struct st_columndef MI_COLUMNDEF;

class AlterColumn;
class AlterDrop;
class AlterInfo;
class Arg_comparator;
class Cached_item;
class CachedDirectory;
class COND_EQUAL;
class CopyField;
class CopyInfo;
class Create_func;
class CreateField;
class Cursor;
class Date;
class DateTime;
class Diagnostics_area;
class DRIZZLE_ERROR;
class DrizzleLock;
class DrizzleXid;
class Field;
class Field_blob;
class file_exchange;
class ForeignKeyInfo;
class Hybrid_type;
class Hybrid_type_traits;
class Identifier;
class Index_hint;
class Internal_error_handler;
class Item;
class Item_bool_func2;
class Item_cache;
class Item_equal;
class Item_field;
class Item_func;
class Item_func_not_all;
class Item_func_set_user_var;
class Item_ident;
class Item_in_optimizer;
class Item_in_subselect;
class Item_maxmin_subselect;
class Item_outer_ref;
class Item_row;
class Item_subselect;
class Item_sum;
class Item_sum_avg;
class Item_sum_hybrid;
class Item_sum_std;
class Item_sum_variance;
class Join;
class JoinTable;
class KeyInfo;
class LEX;
class Lex_Column;
class Lex_input_stream;
class lex_string_t;
class Name_resolution_context;
class NamedSavepoint;
class Natural_join_column;
class ResourceContext;
class RorIntersectReadPlan;
class SecurityContext;
class Select_Lex;
class Select_Lex_Unit;
class select_result;
class select_result_interceptor;
class select_union;
class SendField;
class Session;
class SortField;
class SortParam;
class StoredKey;
class st_lex_symbol;
class String;
class subselect_engine;
class subselect_hash_sj_engine;
class sys_var;
class sys_var_str;
class system_status_var;
class Table;
class Table_ident;
class TableList;
class TableShare;
class TableShareInstance;
class Temporal;
class TemporalInterval;
class TemporalIntervalDayOrLess;
class TemporalIntervalDayOrWeek;
class TemporalIntervalYear;
class TemporalIntervalYearMonth;
class Time;
class Time_zone;
class Timestamp;
class Tmp_Table_Param;
class TYPELIB;
class Unique;
class user_var_entry;
class var;
class XID;

struct CacheField;
struct Ha_data;
struct charset_info_st;
struct option;
struct Order;

typedef Item COND;
typedef uint64_t query_id_t;
typedef int64_t session_id_t;
typedef uint64_t my_xid;

}
# 24 "./drizzled/memory/root.h" 2
# 1 "./drizzled/definitions.h" 1
# 26 "./drizzled/definitions.h"
       

# 1 "./drizzled/enum.h" 1
# 21 "./drizzled/enum.h"
       

namespace drizzled
{
# 38 "./drizzled/enum.h"
enum Derivation
{
  DERIVATION_IGNORABLE= 5,
  DERIVATION_COERCIBLE= 4,
  DERIVATION_SYSCONST= 3,
  DERIVATION_IMPLICIT= 2,
  DERIVATION_NONE= 1,
  DERIVATION_EXPLICIT= 0
};

enum enum_parsing_place
{
  NO_MATTER,
  IN_HAVING,
  SELECT_LIST,
  IN_WHERE,
  IN_ON
};

enum enum_mysql_completiontype
{
  ROLLBACK_RELEASE= -2,
  ROLLBACK= 1,
  ROLLBACK_AND_CHAIN= 7,
  COMMIT_RELEASE= -1,
  COMMIT= 0,
  COMMIT_AND_CHAIN= 6
};

enum enum_check_fields
{
  CHECK_FIELD_IGNORE,
  CHECK_FIELD_WARN,
  CHECK_FIELD_ERROR_FOR_NULL
};

enum sql_var_t
{
  OPT_DEFAULT= 0,
  OPT_SESSION,
  OPT_GLOBAL
};

enum column_format_type
{
  COLUMN_FORMAT_TYPE_NOT_USED= -1,
  COLUMN_FORMAT_TYPE_DEFAULT= 0,
  COLUMN_FORMAT_TYPE_FIXED= 1,
  COLUMN_FORMAT_TYPE_DYNAMIC= 2
};





enum enum_table_category
{



  TABLE_UNKNOWN_CATEGORY=0,
# 111 "./drizzled/enum.h"
  TABLE_CATEGORY_TEMPORARY=1,
# 121 "./drizzled/enum.h"
  TABLE_CATEGORY_USER=2,
# 143 "./drizzled/enum.h"
  TABLE_CATEGORY_INFORMATION
};

enum enum_mark_columns
{
  MARK_COLUMNS_NONE,
  MARK_COLUMNS_READ,
  MARK_COLUMNS_WRITE
};

enum enum_filetype
{
  FILETYPE_CSV,
  FILETYPE_XML
};

enum find_item_error_report_type
{
  REPORT_ALL_ERRORS,
  REPORT_EXCEPT_NOT_FOUND,
  IGNORE_ERRORS,
  REPORT_EXCEPT_NON_UNIQUE,
  IGNORE_EXCEPT_NON_UNIQUE
};
# 178 "./drizzled/enum.h"
enum timestamp_auto_set_type
{
  TIMESTAMP_NO_AUTO_SET= 0,
  TIMESTAMP_AUTO_SET_ON_INSERT= 1,
  TIMESTAMP_AUTO_SET_ON_UPDATE= 2,
  TIMESTAMP_AUTO_SET_ON_BOTH= 3
};

enum enum_ha_read_modes
{
  RFIRST,
  RNEXT,
  RPREV,
  RLAST,
  RKEY,
  RNEXT_SAME
};

enum enum_tx_isolation
{
  ISO_READ_UNCOMMITTED,
  ISO_READ_COMMITTED,
  ISO_REPEATABLE_READ,
  ISO_SERIALIZABLE
};


enum SHOW_COMP_OPTION
{
  SHOW_OPTION_YES,
  SHOW_OPTION_NO,
  SHOW_OPTION_DISABLED
};
# 222 "./drizzled/enum.h"
enum enum_sql_command {
  SQLCOM_SELECT,
  SQLCOM_CREATE_TABLE,
  SQLCOM_CREATE_INDEX,
  SQLCOM_ALTER_TABLE,
  SQLCOM_UPDATE,
  SQLCOM_INSERT,
  SQLCOM_INSERT_SELECT,
  SQLCOM_DELETE,
  SQLCOM_TRUNCATE,
  SQLCOM_DROP_TABLE,
  SQLCOM_DROP_INDEX,
  SQLCOM_SHOW_CREATE,
  SQLCOM_SHOW_CREATE_DB,
  SQLCOM_LOAD,
  SQLCOM_SET_OPTION,
  SQLCOM_UNLOCK_TABLES,
  SQLCOM_CHANGE_DB,
  SQLCOM_CREATE_DB,
  SQLCOM_DROP_DB,
  SQLCOM_ALTER_DB,
  SQLCOM_REPLACE,
  SQLCOM_REPLACE_SELECT,
  SQLCOM_CHECK,
  SQLCOM_FLUSH,
  SQLCOM_KILL,
  SQLCOM_ANALYZE,
  SQLCOM_ROLLBACK,
  SQLCOM_ROLLBACK_TO_SAVEPOINT,
  SQLCOM_COMMIT,
  SQLCOM_SAVEPOINT,
  SQLCOM_RELEASE_SAVEPOINT,
  SQLCOM_BEGIN,
  SQLCOM_RENAME_TABLE,
  SQLCOM_SHOW_WARNS,
  SQLCOM_EMPTY_QUERY,
  SQLCOM_SHOW_ERRORS,
  SQLCOM_CHECKSUM,





  SQLCOM_END
};

enum enum_duplicates
{
  DUP_ERROR,
  DUP_REPLACE,
  DUP_UPDATE
};

enum drizzle_exit_codes
{
  EXIT_UNSPECIFIED_ERROR = 1,
  EXIT_UNKNOWN_OPTION,
  EXIT_AMBIGUOUS_OPTION,
  EXIT_NO_ARGUMENT_ALLOWED,
  EXIT_ARGUMENT_REQUIRED,
  EXIT_VAR_PREFIX_NOT_UNIQUE,
  EXIT_UNKNOWN_VARIABLE,
  EXIT_OUT_OF_MEMORY,
  EXIT_UNKNOWN_SUFFIX,
  EXIT_NO_PTR_TO_VARIABLE,
  EXIT_CANNOT_CONNECT_TO_SERVICE,
  EXIT_OPTION_DISABLED,
  EXIT_ARGUMENT_INVALID
};


}
# 29 "./drizzled/definitions.h" 2



# 1 "./drizzled/common.h" 1
# 24 "./drizzled/common.h"
       



# 1 "./drizzled/korr.h" 1
# 20 "./drizzled/korr.h"
       
# 67 "./drizzled/korr.h"
typedef union {
  double v;
  long m[2];
} doubleget_union;
# 29 "./drizzled/common.h" 2
# 151 "./drizzled/common.h"
namespace drizzled
{

enum enum_server_command
{
  COM_SLEEP,
  COM_QUIT,
  COM_USE_SCHEMA,
  COM_QUERY,
  COM_SHUTDOWN,
  COM_CONNECT,
  COM_PING,
  COM_KILL,


  COM_END
};


enum enum_field_types {
                        DRIZZLE_TYPE_LONG,
                        DRIZZLE_TYPE_DOUBLE,
                        DRIZZLE_TYPE_NULL,
                        DRIZZLE_TYPE_TIMESTAMP,
                        DRIZZLE_TYPE_LONGLONG,
                        DRIZZLE_TYPE_DATETIME,
                        DRIZZLE_TYPE_DATE,
                        DRIZZLE_TYPE_VARCHAR,
                        DRIZZLE_TYPE_DECIMAL,
                        DRIZZLE_TYPE_ENUM,
                        DRIZZLE_TYPE_BLOB,
                        DRIZZLE_TYPE_TIME,
                        DRIZZLE_TYPE_BOOLEAN,
                        DRIZZLE_TYPE_UUID,
                        DRIZZLE_TYPE_MICROTIME,
                        DRIZZLE_TYPE_IPV6
};
const int enum_field_types_size= DRIZZLE_TYPE_IPV6 + 1;

}
# 33 "./drizzled/definitions.h" 2

namespace drizzled
{
# 54 "./drizzled/definitions.h"
const uint32_t MAX_KEY = 64;
const uint32_t MAX_REF_PARTS = 16;
const uint32_t MAX_KEY_LENGTH = 4096;
const uint32_t MAX_KEY_LENGTH_DECIMAL_WIDTH = 4;
# 186 "./drizzled/definitions.h"
static const uint32_t UNCACHEABLE_DEPENDENT= 1;
static const uint32_t UNCACHEABLE_RAND= 2;
static const uint32_t UNCACHEABLE_SIDEEFFECT= 3;

static const uint32_t UNCACHEABLE_EXPLAIN= 4;

static const uint32_t UNCACHEABLE_PREPARE= 5;

static const uint32_t UNCACHEABLE_UNITED= 6;





static const uint32_t TL_OPTION_UPDATING= 0;
static const uint32_t TL_OPTION_FORCE_INDEX= 1;
static const uint32_t TL_OPTION_IGNORE_LEAVES= 2;
static const uint32_t TL_OPTION_ALIAS= 3;
static const uint32_t NUM_OF_TABLE_OPTIONS= 4;
# 224 "./drizzled/definitions.h"
typedef void *range_seq_t;

enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };
# 278 "./drizzled/definitions.h"
const uint32_t HA_MAX_REC_LENGTH = 65535;


enum start_transaction_option_t
{
  START_TRANS_NO_OPTIONS,
  START_TRANS_OPT_WITH_CONS_SNAPSHOT
};
# 336 "./drizzled/definitions.h"
typedef int myf;
# 361 "./drizzled/definitions.h"
inline static void clear_timestamp_auto_bits(timestamp_auto_set_type &_target_,
                                             timestamp_auto_set_type _bits_)
{
  _target_= static_cast<timestamp_auto_set_type>(_target_ & ~_bits_);
}
# 378 "./drizzled/definitions.h"
template <typename T>
T MTYP_TYPENR(const T& type)
{
  return static_cast<T>(type & 127);
}




inline static uint32_t f_settype(const enum enum_field_types x)
{
  return (uint32_t(x) << 3);
}


template <class T> void set_if_bigger(T &a, const T &b)
{
  if (a < b)
    a=b;
}

template <class T> void set_if_smaller(T &a, const T &b)
{
  if (a > b)
    a=b;
}
# 425 "./drizzled/definitions.h"
template<class T> inline void safe_delete(T*& ptr)
{
  delete ptr;
  ptr = 0;
}
# 444 "./drizzled/definitions.h"
static const uint32_t ONCE_ALLOC_INIT= 4096;

static const uint32_t RECORD_CACHE_SIZE= 64*1024;
# 580 "./drizzled/definitions.h"
typedef uint64_t table_map;
typedef uint32_t nesting_map;

}
# 25 "./drizzled/memory/root.h" 2



namespace drizzled {
# 38 "./drizzled/memory/root.h"
namespace memory {

static const int KEEP_PREALLOC= 1;

static const int MARK_BLOCKS_FREE= 2;

namespace internal
{
  class UsedMemory
  {
  public:
    UsedMemory *next;
    size_t left;
    size_t size;
  };
}

static const size_t ROOT_MIN_BLOCK_SIZE= (8 + sizeof(internal::UsedMemory) + 8);

class __attribute__ ((visibility("default"))) Root
{
public:
  Root() :
    free(0),
    used(0),
    pre_alloc(0),
    min_malloc(0),
    block_size(0),
    block_num(0),
    first_block_usage(0)
  { }

  Root(size_t block_size_arg)
  {
    free= used= pre_alloc= 0;
    min_malloc= 32;
    block_size= block_size_arg - memory::ROOT_MIN_BLOCK_SIZE;
    block_num= 4;
    first_block_usage= 0;
  }




  internal::UsedMemory *free;




  internal::UsedMemory *used;




  internal::UsedMemory *pre_alloc;




  size_t min_malloc;

  size_t block_size;
  unsigned int block_num;





  unsigned int first_block_usage;

  void reset_defaults(size_t block_size, size_t prealloc_size);
  unsigned char* alloc(size_t Size);
  void mark_blocks_free();
  void* memdup(const void*, size_t);
  char* strdup(const char*);

  char* strdup(const char*, size_t);
  char* strdup(str_ref);
  void init(size_t block_size= ROOT_MIN_BLOCK_SIZE);

  bool alloc_root_inited() const
  {
    return min_malloc != 0;
  }
  void free_root(myf MyFLAGS);
  void* multi_alloc(int unused, ...);

  void* calloc(size_t size)
  {
    void* ptr= alloc(size);
    memset(ptr, 0, size);
    return ptr;
  }
};

}
}

inline void* operator new(size_t size, drizzled::memory::Root& root)
{
  return root.alloc(size);
}

inline void* operator new[](size_t size, drizzled::memory::Root& root)
{
  return root.alloc(size);
}

inline void operator delete(void*, drizzled::memory::Root&)
{
}

inline void operator delete[](void*, drizzled::memory::Root&)
{
}
# 23 "./drizzled/memory/sql_alloc.h" 2


namespace drizzled {
namespace memory {

void* sql_alloc(size_t);
void* sql_calloc(size_t);
char* sql_strdup(const char*);
char* sql_strdup(str_ref);
void* sql_memdup(const void*, size_t);

class __attribute__ ((visibility("default"))) SqlAlloc
{
public:
  static void* operator new(size_t size)
  {
    return memory::sql_alloc(size);
  }

  static void* operator new[](size_t size)
  {
    return memory::sql_alloc(size);
  }

  static void* operator new(size_t size, Root& root)
  {
    return root.alloc(size);
  }

  static void* operator new[](size_t size, Root& root)
  {
    return root.alloc(size);
  }

  static void* operator new(size_t size, Root* root)
  {
    return root->alloc(size);
  }

  static void* operator new[](size_t size, Root* root)
  {
    return root->alloc(size);
  }

  static void operator delete(void*)
  {
  }

  static void operator delete[](void*)
  {
  }

  static void operator delete(void*, Root&)
  {
  }

  static void operator delete[](void*, Root&)
  {
  }

  static void operator delete(void*, Root*)
  {
  }

  static void operator delete[](void*, Root*)
  {
  }
};

}
}
# 23 "./drizzled/cached_item.h" 2
# 1 "./drizzled/sql_string.h" 1
# 20 "./drizzled/sql_string.h"
       






# 1 "/usr/include/c++/4.8/cassert" 1 3
# 41 "/usr/include/c++/4.8/cassert" 3
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 28 "./drizzled/sql_string.h" 2
# 1 "/usr/include/c++/4.8/cstdlib" 1 3
# 39 "/usr/include/c++/4.8/cstdlib" 3
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 29 "./drizzled/sql_string.h" 2
# 1 "/usr/include/c++/4.8/cstring" 1 3
# 39 "/usr/include/c++/4.8/cstring" 3
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 30 "./drizzled/sql_string.h" 2
# 39 "./drizzled/sql_string.h"
namespace drizzled {

extern __attribute__ ((visibility("default"))) String my_empty_string;
extern const String my_null_string;

int sortcmp(const String *a,const String *b, const charset_info_st * const cs);
int stringcmp(const String *a,const String *b);
String *copy_if_not_alloced(String *a,String *b,size_t arg_length);
size_t well_formed_copy_nchars(const charset_info_st * const to_cs,
                                 char *to, size_t to_length,
                                 const charset_info_st * const from_cs,
                                 const char *from, size_t from_length,
                                 size_t nchars,
                                 const char **well_formed_error_pos,
                                 const char **cannot_convert_error_pos,
                                 const char **from_end_pos);


class __attribute__ ((visibility("default"))) String
{
  char *Ptr;
  size_t str_length,Alloced_length;
  bool alloced;
  const charset_info_st *str_charset;

public:
  String();
  String(size_t length_arg);
  String(const char*, const charset_info_st*);
  String(const char*, size_t, const charset_info_st*);
  String(char *str, size_t len, const charset_info_st*);
  String(str_ref, const charset_info_st*);
  String(const String&);

  static void *operator new(size_t size, memory::Root *mem_root);
  static void operator delete(void *, size_t)
  { }
  static void operator delete(void *, memory::Root *)
  { }
  ~String();

  inline void set_charset(const charset_info_st * const charset_arg)
  { str_charset= charset_arg; }
  inline const charset_info_st *charset() const { return str_charset; }
  inline size_t length() const { return str_length;}
  inline size_t alloced_length() const { return Alloced_length;}
  inline char& operator [] (size_t i) const { return Ptr[i]; }
  inline void length(size_t len) { str_length=len; }
  inline bool empty() const { return str_length == 0; }
  inline void mark_as_const() { Alloced_length= 0; }
  inline char *ptr() { return Ptr; }
  inline const char *ptr() const { return Ptr; }
  inline char *c_ptr()
  {
    if (str_length == Alloced_length)
      realloc(str_length);
    else
      Ptr[str_length]= 0;

    return Ptr;
  }
  inline const char* begin() const
  {
    return Ptr;
  }
  inline const char* end() const
  {
    return begin() + size();
  }
  inline const char* data() const
  {
    return Ptr;
  }
  inline size_t size() const
  {
    return length();
  }
  inline const char* c_str()
  {
    if (Ptr && str_length < Alloced_length)
      Ptr[str_length]=0;
    else
      realloc(str_length);
    return Ptr;
  }
  void append_identifier(const char *name, size_t length);
  void append_identifier(str_ref);

  void set(String &str,size_t offset,size_t arg_length)
  {
    ((&str != this) ? static_cast<void> (0) : __assert_fail ("&str != this", "./drizzled/sql_string.h", 129, __PRETTY_FUNCTION__));
    free();
    Ptr= str.ptr()+offset; str_length=arg_length; alloced=0;
    if (str.Alloced_length)
      Alloced_length=str.Alloced_length-offset;
    else
      Alloced_length=0;
    str_charset=str.str_charset;
  }
  inline void set(char *str,size_t arg_length, const charset_info_st * const cs)
  {
    free();
    Ptr= str; str_length=Alloced_length=arg_length ; alloced=0;
    str_charset=cs;
  }

  inline void set(const char *str,size_t arg_length, const charset_info_st * const cs)
  {
    free();
    Ptr= const_cast<char*>(str);
    str_length=arg_length; Alloced_length=0 ; alloced=0;
    str_charset=cs;
  }
  void set_ascii(const char *str, size_t arg_length);

  inline void set_quick(char *str,size_t arg_length, const charset_info_st * const cs)
  {
    if (!alloced)
    {
      Ptr= str; str_length= Alloced_length= arg_length;
    }
    str_charset= cs;
  }

  void set_int(int64_t num, bool unsigned_flag, const charset_info_st * const cs);
  void set(int64_t num, const charset_info_st * const cs)
  { set_int(num, false, cs); }
  void set(uint64_t num, const charset_info_st * const cs)
  { set_int(static_cast<int64_t>(num), true, cs); }
  void set_real(double num,size_t decimals, const charset_info_st* cs);
# 192 "./drizzled/sql_string.h"
  inline void chop()
  {
    Ptr[str_length--]= '\0';
  }

  inline void free()
  {
    if (alloced)
    {
      alloced=0;
      Alloced_length=0;
      ::free(Ptr);
      Ptr=0;
      str_length=0;
    }
  }
  inline void alloc(size_t arg_length)
  {
    if (arg_length >= Alloced_length)
      real_alloc(arg_length);
  }
  void real_alloc(size_t arg_length);
  void realloc(size_t arg_length);
  inline void shrink(size_t arg_length)
  {
    if (arg_length < Alloced_length)
    {
      char *new_ptr;
      if (!(new_ptr= reinterpret_cast<char*>(::realloc(Ptr,arg_length))))
      {
        Alloced_length = 0;
        real_alloc(arg_length);
      }
      else
      {
        Ptr=new_ptr;
        Alloced_length=arg_length;
      }
    }
  }
  bool is_alloced() { return alloced; } const
  inline String& operator = (const String &s)
  {
    if (&s != this)
    {




      ((!s.uses_buffer_owned_by(this)) ? static_cast<void> (0) : __assert_fail ("!s.uses_buffer_owned_by(this)", "./drizzled/sql_string.h", 241, __PRETTY_FUNCTION__));
      free();
      Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
      alloced=0;
    }
    return *this;
  }

  void copy();
  void copy(const String&);
  void copy(const std::string&, const charset_info_st*);
  void copy(const char*, size_t, const charset_info_st*);
  static bool needs_conversion(size_t arg_length, const charset_info_st* cs_from, const charset_info_st* cs_to);
  void set_or_copy_aligned(const char *s, size_t arg_length, const charset_info_st*);
  void copy(const char*s,size_t arg_length, const charset_info_st& csto);
  void append(const char*, size_t);
  void append(str_ref);
  void append_with_prefill(const char *s, size_t arg_length, size_t full_length, char fill_char);
  int strstr(const String &search,size_t offset=0);
  int strrstr(const String &search,size_t offset=0);
  void replace(size_t offset,size_t arg_length,const char *to,size_t length);
  void replace(size_t offset,size_t arg_length,const String &to);

  inline void append(char chr)
  {
    if (str_length < Alloced_length)
    {
      Ptr[str_length++]=chr;
    }
    else
    {
      realloc(str_length+1);
      Ptr[str_length++]=chr;
    }
  }
  friend int sortcmp(const String *a,const String *b, const charset_info_st * const cs);
  friend int stringcmp(const String *a,const String *b);
  friend String *copy_if_not_alloced(String *a,String *b,size_t arg_length);
  size_t numchars() const;
  int charpos(int i, size_t offset= 0) const;

  void reserve(size_t space_needed)
  {
    realloc(str_length + space_needed);
  }
  void reserve(size_t space_needed, size_t grow_by);

  inline void append(const char *s, size_t arg_length, size_t step_alloc)
  {
    size_t new_length= arg_length + str_length;
    if (new_length > Alloced_length)
   realloc(new_length + step_alloc);
    memcpy(Ptr+str_length, s, arg_length);
    str_length+= arg_length;
  }

  void print(String&) const;


  void swap(String &s);

  inline bool uses_buffer_owned_by(const String *s) const
  {
    return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->str_length);
  }
};

bool check_if_only_end_space(const charset_info_st* const, char *str, char *end);

std::ostream& operator<<(std::ostream&, const String&);

}

bool operator==(const drizzled::String &s1, const drizzled::String &s2);
bool operator!=(const drizzled::String &s1, const drizzled::String &s2);
# 24 "./drizzled/cached_item.h" 2
# 1 "./drizzled/type/decimal.h" 1
# 16 "./drizzled/type/decimal.h"
       
# 1 "/usr/include/assert.h" 1 3 4
# 18 "./drizzled/type/decimal.h" 2


# 1 "./drizzled/type/time.h" 1
# 21 "./drizzled/type/time.h"
       
# 36 "./drizzled/type/time.h"
namespace drizzled {

extern uint64_t log_10_int[20];
extern unsigned char days_in_month[];
# 82 "./drizzled/type/time.h"
namespace type {

enum timestamp_t
{
  DRIZZLE_TIMESTAMP_NONE= -2, DRIZZLE_TIMESTAMP_ERROR= -1,
  DRIZZLE_TIMESTAMP_DATE= 0, DRIZZLE_TIMESTAMP_DATETIME= 1, DRIZZLE_TIMESTAMP_TIME= 2
};

enum cut_t
{
  VALID= 0,
  CUT= 1,
  INVALID= 2
};





inline bool is_valid(datetime_t value)
{
  return value != -1;
}

class Time
{
public:
  Time()
  {
    reset();
  }

  Time(uint32_t year_arg,
       uint32_t month_arg,
       uint32_t day_arg,
       uint32_t hour_arg,
       uint32_t minute_arg,
       uint32_t second_arg,
       usec_t second_part_arg,
       timestamp_t type_arg) :
    year(year_arg),
    month(month_arg),
    day(day_arg),
    hour(hour_arg),
    minute(minute_arg),
    second(second_arg),
    second_part(second_part_arg),
    neg(false),
    time_type(type_arg)
  {
  }

  Time(uint32_t hour_arg,
       uint32_t minute_arg,
       uint32_t second_arg,
       usec_t second_part_arg,
       bool neg_arg) :
    year(0),
    month(0),
    day(0),
    hour(hour_arg),
    minute(minute_arg),
    second(second_arg),
    second_part(second_part_arg),
    neg(neg_arg),
    time_type(DRIZZLE_TIMESTAMP_TIME)
  {
  }

  uint32_t year, month, day, hour, minute, second;
  usec_t second_part;
  bool neg;
  timestamp_t time_type;

  void reset()
  {
    year= month= day= hour= minute= second= second_part= 0;
    neg= false;
    time_type= DRIZZLE_TIMESTAMP_DATE;
  }

  timestamp_t type() const
  {
    return time_type;
  }

  void convert(drizzled::String &str, timestamp_t arg= type::DRIZZLE_TIMESTAMP_DATETIME);
  void convert(char *str, size_t &to_length, timestamp_t arg= type::DRIZZLE_TIMESTAMP_DATETIME);
  void convert(datetime_t &datetime, timestamp_t arg= type::DRIZZLE_TIMESTAMP_DATETIME);
  void convert(datetime_t &ret, int64_t nr, uint32_t flags);
  void convert(datetime_t &ret, int64_t nr, uint32_t flags, type::cut_t &was_cut);
  void convert(type::epoch_t &epoch, long *my_timezone) const;

  void truncate(const timestamp_t arg);

  bool store(const char *str,uint32_t length, int &warning, type::timestamp_t arg= DRIZZLE_TIMESTAMP_TIME);
  type::timestamp_t store(const char *str, uint32_t length, uint32_t flags, type::cut_t &was_cut);
  type::timestamp_t store(const char *str, uint32_t length, uint32_t flags);
  void store(type::epoch_t from);
  void store(type::epoch_t from, usec_t from_fractional_seconds);
  void store(const tm&);
  void store(const timeval&);


  static const uint32_t FRACTIONAL_DIGITS= 1000000;
  static const size_t MAX_STRING_LENGTH= 32;

  bool check(bool not_zero_date, uint32_t flags, type::cut_t &was_cut) const;

  inline bool isValidEpoch() const
  {
    if ((year < (1900 + 70 - 1)) or (year == (1900 + 70 - 1) && (month < 12 || day < 31)))
    {
      return false;
    }

    return true;
  }
};

}

long calc_daynr(uint32_t year,uint32_t month,uint32_t day);
uint32_t calc_days_in_year(uint32_t year);
uint32_t year_2000_handling(uint32_t year);

void init_time();
# 225 "./drizzled/type/time.h"
enum interval_type
{
  INTERVAL_YEAR, INTERVAL_QUARTER, INTERVAL_MONTH, INTERVAL_WEEK, INTERVAL_DAY,
  INTERVAL_HOUR, INTERVAL_MINUTE, INTERVAL_SECOND, INTERVAL_MICROSECOND,
  INTERVAL_YEAR_MONTH, INTERVAL_DAY_HOUR, INTERVAL_DAY_MINUTE,
  INTERVAL_DAY_SECOND, INTERVAL_HOUR_MINUTE, INTERVAL_HOUR_SECOND,
  INTERVAL_MINUTE_SECOND, INTERVAL_DAY_MICROSECOND, INTERVAL_HOUR_MICROSECOND,
  INTERVAL_MINUTE_MICROSECOND, INTERVAL_SECOND_MICROSECOND, INTERVAL_LAST
};

}
# 21 "./drizzled/type/decimal.h" 2

namespace drizzled {

typedef enum
{
  TRUNCATE= 0,
  HALF_EVEN,
  HALF_UP,
  CEILING,
  FLOOR
} decimal_round_mode;
typedef int32_t decimal_digit_t;

struct decimal_t {
  int intg, frac, len;
  bool sign;
  decimal_digit_t *buf;


  inline void set_zero()
  {
    buf[0]= 0;
    intg= 1;
    frac= 0;
    sign= 0;
  }


  inline void negate()
  {
    sign^=1;
  }

  int isZero() const;

};

int internal_str2dec(char *from, decimal_t *to, char **end,
                     bool fixed);
int decimal2string(const decimal_t *from, char *to, int *to_len,
                   int fixed_precision, int fixed_decimals,
                   char filler);
int decimal2uint64_t(const decimal_t *from, uint64_t *to);
int uint64_t2decimal(const uint64_t from, decimal_t *to);
int decimal2int64_t(const decimal_t *from, int64_t *to);
int int64_t2decimal(const int64_t from, decimal_t *to);
int decimal2double(const decimal_t *from, double *to);
int double2decimal(const double from, decimal_t *to);
int decimal_actual_fraction(decimal_t *from);
int decimal2bin(const decimal_t *from, unsigned char *to, int precision, int scale);
int bin2decimal(const unsigned char *from, decimal_t *to, int precision, int scale);

int decimal_bin_size(int precision, int scale);

int decimal_intg(const decimal_t *from);
int decimal_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_cmp(const decimal_t *from1, const decimal_t *from2);
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to,
                int scale_incr);
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to);
int decimal_round(const decimal_t *from, decimal_t *to, int new_scale,
                  decimal_round_mode mode);
void max_decimal(int precision, int frac, decimal_t *to);

inline int string2decimal(char *from, decimal_t *to, char **end)
{
  return internal_str2dec(from, to, end, false);
}






inline int decimal_string_size(const decimal_t *dec)
{
  return (dec->intg ? dec->intg : 1) + dec->frac + (dec->frac > 0) + 2;
}
# 148 "./drizzled/type/decimal.h"
inline int class_decimal_int_part(uint32_t precision, uint32_t decimals)
{
  return precision - ((decimals == 31) ? 0 : decimals);
}

int decimal_operation_results(int result);

inline void max_Decimal(type::Decimal *to, int precision, int frac)
{
  (((precision <= ((9 * 9) - 8*2))&& (frac <= 30)) ? static_cast<void> (0) : __assert_fail ("(precision <= ((9 * 9) - 8*2))&& (frac <= 30)",
 "./drizzled/type/decimal.h"
# 157 "./drizzled/type/decimal.h" 3 4
  ,
 158
# 157 "./drizzled/type/decimal.h" 3 4
  , __PRETTY_FUNCTION__))
                                          ;
  max_decimal(precision, frac, (decimal_t*) to);
}

inline void max_internal_decimal(type::Decimal *to)
{
  max_Decimal(to, ((9 * 9) - 8*2), 0);
}

inline int check_result(uint32_t mask, int result)
{
  if (result & mask)
    decimal_operation_results(result);
  return result;
}

namespace type {
# 183 "./drizzled/type/decimal.h"
class Decimal : public decimal_t
{
  decimal_digit_t buffer[9];

public:

  void init()
  {
    len= 9;
    buf= buffer;


    for (uint32_t i= 0; i < 9; i++)
      buffer[i]= i;

  }

  Decimal()
  {
    init();
  }

  void fix_buffer_pointer() { buf= buffer; }
  bool sign() const { return decimal_t::sign; }
  void sign(bool s) { decimal_t::sign= s; }
  uint32_t precision() const { return intg + frac; }

  int val_int32(uint32_t mask, bool unsigned_flag, int64_t *l) const
  {
    type::Decimal rounded;

    decimal_round(static_cast<const decimal_t*>(this), &rounded, 0, HALF_UP);
    return check_result(mask, (unsigned_flag ?
                               decimal2uint64_t(&rounded, reinterpret_cast<uint64_t *>(l)) :
                               decimal2int64_t(&rounded, l)));
  }

  int string_length() const
  {
    return decimal_string_size(this);
  }

  int val_binary(uint32_t mask, unsigned char *bin, int prec, int scale) const;

  int store(uint32_t mask, const char *from, uint32_t length, const charset_info_st * charset);

  int store(uint32_t mask, char *str, char **end)
  {
    return check_result_and_overflow(mask, string2decimal(str, static_cast<decimal_t*>(this), end));
  }

  int store(uint32_t mask, const String *str)
  {
    return store(mask, str->ptr(), str->length(), str->charset());
  }

  int check_result_and_overflow(uint32_t mask, int result)
  {
    if (check_result(mask, result) & 2)
    {
      bool _sign= sign();
      fix_buffer_pointer();
      max_internal_decimal(this);
      sign(_sign);
    }
    return result;
  }

  void convert(double &value) const;
};

}

std::ostream& operator<<(std::ostream& output, const type::Decimal &dec);

inline uint32_t class_decimal_length_to_precision(uint32_t length, uint32_t scale,
                                                  bool unsigned_flag)
{
  return (uint32_t) (length - (scale>0 ? 1:0) - (unsigned_flag ? 0:1));
}

inline uint32_t class_decimal_precision_to_length(uint32_t precision, uint8_t scale,
                                                  bool unsigned_flag)
{
  set_if_smaller(precision, (uint32_t)((9 * 9) - 8*2));
  return static_cast<uint32_t>(precision + (scale>0 ? 1:0) + (unsigned_flag ? 0:1));
}


inline
int class_decimal_max_length(const type::Decimal *d)
{

  return decimal_string_size(d) - 1;
}


inline
int class_decimal_get_binary_size(uint32_t precision, uint32_t scale)
{
  return decimal_bin_size(static_cast<int>(precision), static_cast<int>(scale));
}


inline
void class_decimal2decimal(const type::Decimal *from, type::Decimal *to)
{
  *to= *from;
  to->fix_buffer_pointer();
}


inline
int binary2_class_decimal(uint32_t mask, const unsigned char *bin, type::Decimal *d, int prec,
        int scale)
{
  return check_result(mask, bin2decimal(bin, static_cast<decimal_t*>(d), prec, scale));
}


inline
int class_decimal_round(uint32_t mask, const type::Decimal *from, int scale,
                     bool truncate, type::Decimal *to)
{
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, scale,
                                          (truncate ? TRUNCATE : HALF_UP)));
}


inline
int class_decimal_floor(uint32_t mask, const type::Decimal *from, type::Decimal *to)
{
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, FLOOR));
}


inline
int class_decimal_ceiling(uint32_t mask, const type::Decimal *from, type::Decimal *to)
{
  return check_result(mask, decimal_round(static_cast<const decimal_t*>(from), to, 0, CEILING));
}


int class_decimal2string(const type::Decimal *d,
                         uint32_t fixed_dec, String *str);


inline
int class_decimal2double(uint32_t, const type::Decimal *d, double *result)
{

  return decimal2double(static_cast<const decimal_t*>(d), result);
}


type::Decimal *date2_class_decimal(type::Time *ltime, type::Decimal *dec);


inline
int double2_class_decimal(uint32_t mask, double val, type::Decimal *d)
{
  return d->check_result_and_overflow(mask, double2decimal(val, static_cast<decimal_t*>(d)));
}


inline
int int2_class_decimal(uint32_t mask, int64_t i, bool unsigned_flag, type::Decimal *d)
{
  return check_result(mask, (unsigned_flag ?
        uint64_t2decimal(static_cast<uint64_t>(i), d) :
        int64_t2decimal(i, d)));
}


inline
void class_decimal_neg(decimal_t *arg)
{
  if (arg->isZero())
  {
    arg->sign= 0;
    return;
  }
  arg->negate();
}


inline
int class_decimal_add(uint32_t mask, type::Decimal *res, const type::Decimal *a,
     const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_add(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b), res));
}


inline
int class_decimal_sub(uint32_t mask, type::Decimal *res, const type::Decimal *a,
     const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_sub(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b), res));
}


inline
int class_decimal_mul(uint32_t mask, type::Decimal *res, const type::Decimal *a,
     const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_mul(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b),res));
}


inline
int class_decimal_div(uint32_t mask, type::Decimal *res, const type::Decimal *a,
     const type::Decimal *b, int div_scale_inc)
{
  return res->check_result_and_overflow(mask,
                                        decimal_div(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b),res,
                                                    div_scale_inc));
}


inline
int class_decimal_mod(uint32_t mask, type::Decimal *res, const type::Decimal *a,
     const type::Decimal *b)
{
  return res->check_result_and_overflow(mask,
                                        decimal_mod(static_cast<const decimal_t*>(a),
                                                    static_cast<const decimal_t*>(b),res));
}






inline
int class_decimal_cmp(const type::Decimal *a, const type::Decimal *b)
{
  return decimal_cmp(static_cast<const decimal_t*>(a),
                     static_cast<const decimal_t*>(b));
}


inline
int class_decimal_intg(const type::Decimal *a)
{
  return decimal_intg(static_cast<const decimal_t*>(a));
}


void class_decimal_trim(uint32_t *precision, uint32_t *scale);

inline type::Decimal &decimal_zero_const()
{
  static type::Decimal _decimal_zero;
  return _decimal_zero;
}

double my_double_round(double value, int64_t dec, bool dec_unsigned,
                       bool truncate);




}
# 25 "./drizzled/cached_item.h" 2

namespace drizzled {

class Cached_item :public memory::SqlAlloc
{
public:
  bool null_value;
  Cached_item() :null_value(0) {}
  virtual bool cmp(void)=0;
  virtual ~Cached_item();
};

class Cached_item_str :public Cached_item
{
  Item *item;
  String value,tmp_value;
public:
  Cached_item_str(Session *session, Item *arg);
  bool cmp(void);
  ~Cached_item_str();
};


class Cached_item_real :public Cached_item
{
  Item *item;
  double value;
public:
  Cached_item_real(Item *item_par) :item(item_par),value(0.0) {}
  bool cmp(void);
};

class Cached_item_int :public Cached_item
{
  Item *item;
  int64_t value;
public:
  Cached_item_int(Item *item_par) :item(item_par),value(0) {}
  bool cmp(void);
};


class Cached_item_decimal :public Cached_item
{
  Item *item;
  type::Decimal value;
public:
  Cached_item_decimal(Item *item_par);
  bool cmp(void);
};

class Cached_item_field :public Cached_item
{
  unsigned char *buff;
  Field *field;
  uint32_t length;

public:
  Cached_item_field(Field *arg_field);
  bool cmp(void);
};

Cached_item *new_Cached_item(Session *session, Item *item);

}
# 27 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/check_stack_overrun.h" 1
# 20 "./drizzled/check_stack_overrun.h"
       



namespace drizzled {
# 33 "./drizzled/check_stack_overrun.h"
bool check_stack_overrun(Session *session, long margin, void *buff);

}
# 28 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/current_session.h" 1
# 21 "./drizzled/current_session.h"
       


# 1 "/usr/include/boost/thread/tss.hpp" 1 3 4
# 10 "/usr/include/boost/thread/tss.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/thread_heap_alloc.hpp" 1 3 4
# 17 "/usr/include/boost/thread/detail/thread_heap_alloc.hpp" 3 4
# 1 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 1 3 4







# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 9 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 2 3 4

namespace boost
{
    namespace detail
    {
        template<typename T>
        inline T* heap_new()
        {
            return new T();
        }
# 44 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 3 4
        template<typename T,typename A1>
        inline T* heap_new_impl(A1 a1)
        {
            return new T(a1);
        }
        template<typename T,typename A1,typename A2>
        inline T* heap_new_impl(A1 a1,A2 a2)
        {
            return new T(a1,a2);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3)
        {
            return new T(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new_impl(A1 a1,A2 a2,A3 a3,A4 a4)
        {
            return new T(a1,a2,a3,a4);
        }

        template<typename T,typename A1>
        inline T* heap_new(A1 const& a1)
        {
            return heap_new_impl<T,A1 const&>(a1);
        }
        template<typename T,typename A1>
        inline T* heap_new(A1& a1)
        {
            return heap_new_impl<T,A1&>(a1);
        }

        template<typename T,typename A1,typename A2>
        inline T* heap_new(A1 const& a1,A2 const& a2)
        {
            return heap_new_impl<T,A1 const&,A2 const&>(a1,a2);
        }
        template<typename T,typename A1,typename A2>
        inline T* heap_new(A1& a1,A2 const& a2)
        {
            return heap_new_impl<T,A1&,A2 const&>(a1,a2);
        }
        template<typename T,typename A1,typename A2>
        inline T* heap_new(A1 const& a1,A2& a2)
        {
            return heap_new_impl<T,A1 const&,A2&>(a1,a2);
        }
        template<typename T,typename A1,typename A2>
        inline T* heap_new(A1& a1,A2& a2)
        {
            return heap_new_impl<T,A1&,A2&>(a1,a2);
        }

        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3)
        {
            return heap_new_impl<T,A1 const&,A2 const&,A3 const&>(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3)
        {
            return heap_new_impl<T,A1&,A2 const&,A3 const&>(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3)
        {
            return heap_new_impl<T,A1 const&,A2&,A3 const&>(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1& a1,A2& a2,A3 const& a3)
        {
            return heap_new_impl<T,A1&,A2&,A3 const&>(a1,a2,a3);
        }

        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3)
        {
            return heap_new_impl<T,A1 const&,A2 const&,A3&>(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1& a1,A2 const& a2,A3& a3)
        {
            return heap_new_impl<T,A1&,A2 const&,A3&>(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1 const& a1,A2& a2,A3& a3)
        {
            return heap_new_impl<T,A1 const&,A2&,A3&>(a1,a2,a3);
        }
        template<typename T,typename A1,typename A2,typename A3>
        inline T* heap_new(A1& a1,A2& a2,A3& a3)
        {
            return heap_new_impl<T,A1&,A2&,A3&>(a1,a2,a3);
        }

        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1&,A2 const&,A3 const&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1 const&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1&,A2&,A3 const&,A4 const&>(a1,a2,a3,a4);
        }

        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1 const&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1&,A2 const&,A3&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1 const&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2& a2,A3& a3,A4 const& a4)
        {
            return heap_new_impl<T,A1&,A2&,A3&,A4 const&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2 const& a2,A3 const& a3,A4& a4)
        {
            return heap_new_impl<T,A1 const&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2 const& a2,A3 const& a3,A4& a4)
        {
            return heap_new_impl<T,A1&,A2 const&,A3 const&,A4&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2& a2,A3 const& a3,A4& a4)
        {
            return heap_new_impl<T,A1 const&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2& a2,A3 const& a3,A4& a4)
        {
            return heap_new_impl<T,A1&,A2&,A3 const&,A4&>(a1,a2,a3,a4);
        }

        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2 const& a2,A3& a3,A4& a4)
        {
            return heap_new_impl<T,A1 const&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2 const& a2,A3& a3,A4& a4)
        {
            return heap_new_impl<T,A1&,A2 const&,A3&,A4&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1 const& a1,A2& a2,A3& a3,A4& a4)
        {
            return heap_new_impl<T,A1 const&,A2&,A3&,A4&>(a1,a2,a3,a4);
        }
        template<typename T,typename A1,typename A2,typename A3,typename A4>
        inline T* heap_new(A1& a1,A2& a2,A3& a3,A4& a4)
        {
            return heap_new_impl<T,A1&,A2&,A3&,A4&>(a1,a2,a3,a4);
        }


        template<typename T>
        inline void heap_delete(T* data)
        {
            delete data;
        }

        template<typename T>
        struct do_heap_delete
        {
            void operator()(T* data) const
            {
                detail::heap_delete(data);
            }
        };
    }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 241 "/usr/include/boost/thread/pthread/thread_heap_alloc.hpp" 2 3 4
# 18 "/usr/include/boost/thread/detail/thread_heap_alloc.hpp" 2 3 4
# 11 "/usr/include/boost/thread/tss.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 13 "/usr/include/boost/thread/tss.hpp" 2 3 4

namespace boost
{
    namespace detail
    {
        struct tss_cleanup_function
        {
            virtual ~tss_cleanup_function()
            {}

            virtual void operator()(void* data)=0;
        };

        __attribute__((visibility("default"))) void set_tss_data(void const* key,boost::shared_ptr<tss_cleanup_function> func,void* tss_data,bool cleanup_existing);
        __attribute__((visibility("default"))) void* get_tss_data(void const* key);
    }

    template <typename T>
    class thread_specific_ptr
    {
    private:
        thread_specific_ptr(thread_specific_ptr&);
        thread_specific_ptr& operator=(thread_specific_ptr&);

        struct delete_data:
            detail::tss_cleanup_function
        {
            void operator()(void* data)
            {
                delete static_cast<T*>(data);
            }
        };

        struct run_custom_cleanup_function:
            detail::tss_cleanup_function
        {
            void (*cleanup_function)(T*);

            explicit run_custom_cleanup_function(void (*cleanup_function_)(T*)):
                cleanup_function(cleanup_function_)
            {}

            void operator()(void* data)
            {
                cleanup_function(static_cast<T*>(data));
            }
        };


        boost::shared_ptr<detail::tss_cleanup_function> cleanup;

    public:
        typedef T element_type;

        thread_specific_ptr():
            cleanup(detail::heap_new<delete_data>(),detail::do_heap_delete<delete_data>())
        {}
        explicit thread_specific_ptr(void (*func_)(T*))
        {
            if(func_)
            {
                cleanup.reset(detail::heap_new<run_custom_cleanup_function>(func_),detail::do_heap_delete<run_custom_cleanup_function>());
            }
        }
        ~thread_specific_ptr()
        {
            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,true);
        }

        T* get() const
        {
            return static_cast<T*>(detail::get_tss_data(this));
        }
        T* operator->() const
        {
            return get();
        }
        T& operator*() const
        {
            return *get();
        }
        T* release()
        {
            T* const temp=get();
            detail::set_tss_data(this,boost::shared_ptr<detail::tss_cleanup_function>(),0,false);
            return temp;
        }
        void reset(T* new_value=0)
        {
            T* const current_value=get();
            if(current_value!=new_value)
            {
                detail::set_tss_data(this,cleanup,new_value,true);
            }
        }
    };
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 112 "/usr/include/boost/thread/tss.hpp" 2 3 4
# 25 "./drizzled/current_session.h" 2



namespace drizzled {

__attribute__ ((visibility("default"))) Session *_current_session();

memory::Root *current_mem_root();

void setCurrentSession(Session*);
void setCurrentMemRoot(memory::Root*);

}
# 29 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/error.h" 1
# 21 "./drizzled/error.h"
       


# 1 "/usr/include/boost/unordered_map.hpp" 1 3 4
# 16 "/usr/include/boost/unordered_map.hpp" 3 4
# 1 "/usr/include/boost/unordered/unordered_map.hpp" 1 3 4
# 16 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
# 1 "/usr/include/boost/unordered/unordered_map_fwd.hpp" 1 3 4
# 16 "/usr/include/boost/unordered/unordered_map_fwd.hpp" 3 4
# 1 "/usr/include/boost/functional/hash_fwd.hpp" 1 3 4





# 1 "/usr/include/boost/functional/hash/hash_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/functional/hash/hash_fwd.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 19 "/usr/include/boost/functional/hash/hash_fwd.hpp" 2 3 4


namespace boost
{
    template <class T> struct hash;




    template <class T> void hash_combine(std::size_t& seed, T const& v);


    template <class It> std::size_t hash_range(It, It);
    template <class It> void hash_range(std::size_t&, It, It);





}
# 7 "/usr/include/boost/functional/hash_fwd.hpp" 2 3 4
# 17 "/usr/include/boost/unordered/unordered_map_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/unordered/detail/fwd.hpp" 1 3 4
# 14 "/usr/include/boost/unordered/detail/fwd.hpp" 3 4
namespace boost
{
namespace unordered
{
    struct piecewise_construct_t {};
    const piecewise_construct_t piecewise_construct = piecewise_construct_t();
}
}
# 18 "/usr/include/boost/unordered/unordered_map_fwd.hpp" 2 3 4

namespace boost
{
    namespace unordered
    {
        template <class K,
            class T,
            class H = boost::hash<K>,
            class P = std::equal_to<K>,
            class A = std::allocator<std::pair<const K, T> > >
        class unordered_map;

        template <class K, class T, class H, class P, class A>
        inline bool operator==(unordered_map<K, T, H, P, A> const&,
            unordered_map<K, T, H, P, A> const&);
        template <class K, class T, class H, class P, class A>
        inline bool operator!=(unordered_map<K, T, H, P, A> const&,
            unordered_map<K, T, H, P, A> const&);
        template <class K, class T, class H, class P, class A>
        inline void swap(unordered_map<K, T, H, P, A>&,
                unordered_map<K, T, H, P, A>&);

        template <class K,
            class T,
            class H = boost::hash<K>,
            class P = std::equal_to<K>,
            class A = std::allocator<std::pair<const K, T> > >
        class unordered_multimap;

        template <class K, class T, class H, class P, class A>
        inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
            unordered_multimap<K, T, H, P, A> const&);
        template <class K, class T, class H, class P, class A>
        inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
            unordered_multimap<K, T, H, P, A> const&);
        template <class K, class T, class H, class P, class A>
        inline void swap(unordered_multimap<K, T, H, P, A>&,
                unordered_multimap<K, T, H, P, A>&);
    }

    using boost::unordered::unordered_map;
    using boost::unordered::unordered_multimap;
    using boost::unordered::swap;
    using boost::unordered::operator==;
    using boost::unordered::operator!=;
}
# 17 "/usr/include/boost/unordered/unordered_map.hpp" 2 3 4
# 1 "/usr/include/boost/unordered/detail/equivalent.hpp" 1 3 4
# 14 "/usr/include/boost/unordered/detail/equivalent.hpp" 3 4
# 1 "/usr/include/boost/unordered/detail/table.hpp" 1 3 4
# 10 "/usr/include/boost/unordered/detail/table.hpp" 3 4
# 1 "/usr/include/boost/unordered/detail/buckets.hpp" 1 3 4
# 14 "/usr/include/boost/unordered/detail/buckets.hpp" 3 4
# 1 "/usr/include/boost/unordered/detail/util.hpp" 1 3 4
# 15 "/usr/include/boost/unordered/detail/util.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_empty.hpp" 1 3 4
# 32 "/usr/include/boost/type_traits/is_empty.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 33 "/usr/include/boost/type_traits/is_empty.hpp" 2 3 4







namespace boost {

namespace detail {
# 51 "/usr/include/boost/type_traits/is_empty.hpp" 3 4
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 )





              ;
};
# 211 "/usr/include/boost/type_traits/is_empty.hpp" 3 4
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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 225 "/usr/include/boost/type_traits/is_empty.hpp" 2 3 4
# 16 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_categories.hpp" 1 3 4
# 10 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
# 1 "/usr/include/boost/detail/iterator.hpp" 1 3 4
# 77 "/usr/include/boost/detail/iterator.hpp" 3 4
namespace boost { namespace detail {


template <class Iterator>
struct iterator_traits
    : std::iterator_traits<Iterator>
{};
using std::distance;

}}
# 11 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/arg.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/arg_fwd.hpp" 3 4
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/usr/include/boost/mpl/arg.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/na_assert.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/na_assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/assert.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4




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];




};
# 56 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
}}}
# 21 "/usr/include/boost/mpl/assert.hpp" 2 3 4
# 29 "/usr/include/boost/mpl/assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/pp_counter.hpp" 1 3 4
# 30 "/usr/include/boost/mpl/assert.hpp" 2 3 4





# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 36 "/usr/include/boost/mpl/assert.hpp" 2 3 4
# 62 "/usr/include/boost/mpl/assert.hpp" 3 4
namespace mpl_ {

struct failed {};
# 75 "/usr/include/boost/mpl/assert.hpp" 3 4
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 };
};
# 123 "/usr/include/boost/mpl/assert.hpp" 3 4
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 );
# 212 "/usr/include/boost/mpl/assert.hpp" 3 4
}
# 24 "/usr/include/boost/mpl/aux_/na_assert.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/arity_spec.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/arg_typedef.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/arg.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 3 4
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 ) ) ) };
    };
};



}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 38 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 25 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 3 4
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;
}

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
# 18 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4






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
                      >
                  >
              >
          >
      >
  {};
# 108 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
  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
                      >
                  >
              >
          >
      >
  {
  };
# 142 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
}





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
    >
{};
# 184 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 187 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 17 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4

# 1 "/usr/include/boost/detail/select_type.hpp" 1 3 4
# 16 "/usr/include/boost/detail/select_type.hpp" 3 4
namespace boost { namespace detail {






  template <bool b> struct if_true
  {
      template <class T, class F>
      struct then { typedef T type; };
  };

  template <>
  struct if_true<false>
  {
      template <class T, class F>
      struct then { typedef F type; };
  };
}}
# 19 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4
# 1 "/usr/include/boost/move/move.hpp" 1 3 4
# 20 "/usr/include/boost/move/move.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 21 "/usr/include/boost/move/move.hpp" 2 3 4

# 1 "/usr/include/boost/move/iterator.hpp" 1 3 4
# 17 "/usr/include/boost/move/iterator.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/move/iterator.hpp" 2 3 4



namespace boost {
# 34 "/usr/include/boost/move/iterator.hpp" 3 4
template <class It>
class move_iterator
{
   public:
   typedef It iterator_type;
   typedef typename std::iterator_traits<iterator_type>::value_type value_type;



   typedef typename ::boost::move_detail::if_
      < ::boost::has_move_emulation_enabled<value_type>
      , ::boost::rv<value_type>&
      , value_type & >::type reference;

   typedef It pointer;
   typedef typename std::iterator_traits<iterator_type>::difference_type difference_type;
   typedef typename std::iterator_traits<iterator_type>::iterator_category iterator_category;

   move_iterator()
   {}

   explicit move_iterator(It i)
      : m_it(i)
   {}

   template <class U>
   move_iterator(const move_iterator<U>& u)
      : m_it(u.base())
   {}

   iterator_type base() const
   { return m_it; }

   reference operator*() const
   {

      return *m_it;



   }

   pointer operator->() const
   { return m_it; }

   move_iterator& operator++()
   { ++m_it; return *this; }

   move_iterator<iterator_type> operator++(int)
   { move_iterator<iterator_type> tmp(*this); ++(*this); return tmp; }

   move_iterator& operator--()
   { --m_it; return *this; }

   move_iterator<iterator_type> operator--(int)
   { move_iterator<iterator_type> tmp(*this); --(*this); return tmp; }

   move_iterator<iterator_type> operator+ (difference_type n) const
   { return move_iterator<iterator_type>(m_it + n); }

   move_iterator& operator+=(difference_type n)
   { m_it += n; return *this; }

   move_iterator<iterator_type> operator- (difference_type n) const
   { return move_iterator<iterator_type>(m_it - n); }

   move_iterator& operator-=(difference_type n)
   { m_it -= n; return *this; }

   reference operator[](difference_type n) const
   {

      return m_it[n];



   }

   friend bool operator==(const move_iterator& x, const move_iterator& y)
   { return x.base() == y.base(); }

   friend bool operator!=(const move_iterator& x, const move_iterator& y)
   { return x.base() != y.base(); }

   friend bool operator< (const move_iterator& x, const move_iterator& y)
   { return x.base() < y.base(); }

   friend bool operator<=(const move_iterator& x, const move_iterator& y)
   { return x.base() <= y.base(); }

   friend bool operator> (const move_iterator& x, const move_iterator& y)
   { return x.base() > y.base(); }

   friend bool operator>=(const move_iterator& x, const move_iterator& y)
   { return x.base() >= y.base(); }

   friend difference_type operator-(const move_iterator& x, const move_iterator& y)
   { return x.base() - y.base(); }

   friend move_iterator operator+(difference_type n, const move_iterator& x)
   { return move_iterator(x.base() + n); }

   private:
   It m_it;
};


namespace move_detail {

template <class I>
struct is_move_iterator
   : public ::boost::move_detail::integral_constant<bool, false>
{
};

template <class I>
struct is_move_iterator< ::boost::move_iterator<I> >
   : public ::boost::move_detail::integral_constant<bool, true>
{
};

}
# 165 "/usr/include/boost/move/iterator.hpp" 3 4
template<class It>
inline move_iterator<It> make_move_iterator(const It &it)
{ return move_iterator<It>(it); }
# 178 "/usr/include/boost/move/iterator.hpp" 3 4
template <typename C>
class back_move_insert_iterator
   : public std::iterator<std::output_iterator_tag, void, void, void, void>
{
   C* container_m;

   public:
   typedef C container_type;
   typedef typename C::value_type value_type;
   typedef typename C::reference reference;

   explicit back_move_insert_iterator(C& x) : container_m(&x) { }

   back_move_insert_iterator& operator=(reference x)
   { container_m->push_back(boost::move(x)); return *this; }

   back_move_insert_iterator& operator=(::boost::rv< value_type >& x)
   { reference rx = x; return this->operator=(rx); }

   back_move_insert_iterator& operator*() { return *this; }
   back_move_insert_iterator& operator++() { return *this; }
   back_move_insert_iterator& operator++(int) { return *this; }
};



template <typename C>
inline back_move_insert_iterator<C> back_move_inserter(C& x)
{
   return back_move_insert_iterator<C>(x);
}
# 218 "/usr/include/boost/move/iterator.hpp" 3 4
template <typename C>
class front_move_insert_iterator
   : public std::iterator<std::output_iterator_tag, void, void, void, void>
{
   C* container_m;

public:
   typedef C container_type;
   typedef typename C::value_type value_type;
   typedef typename C::reference reference;

   explicit front_move_insert_iterator(C& x) : container_m(&x) { }

   front_move_insert_iterator& operator=(reference x)
   { container_m->push_front(boost::move(x)); return *this; }

   front_move_insert_iterator& operator=(::boost::rv< value_type >& x)
   { reference rx = x; return this->operator=(rx); }

   front_move_insert_iterator& operator*() { return *this; }
   front_move_insert_iterator& operator++() { return *this; }
   front_move_insert_iterator& operator++(int) { return *this; }
};



template <typename C>
inline front_move_insert_iterator<C> front_move_inserter(C& x)
{
   return front_move_insert_iterator<C>(x);
}






template <typename C>
class move_insert_iterator
   : public std::iterator<std::output_iterator_tag, void, void, void, void>
{
   C* container_m;
   typename C::iterator pos_;

   public:
   typedef C container_type;
   typedef typename C::value_type value_type;
   typedef typename C::reference reference;

   explicit move_insert_iterator(C& x, typename C::iterator pos)
      : container_m(&x), pos_(pos)
   {}

   move_insert_iterator& operator=(reference x)
   {
      pos_ = container_m->insert(pos_, ::boost::move(x));
      ++pos_;
      return *this;
   }

   move_insert_iterator& operator=(::boost::rv< value_type >& x)
   { reference rx = x; return this->operator=(rx); }

   move_insert_iterator& operator*() { return *this; }
   move_insert_iterator& operator++() { return *this; }
   move_insert_iterator& operator++(int) { return *this; }
};



template <typename C>
inline move_insert_iterator<C> move_inserter(C& x, typename C::iterator it)
{
   return move_insert_iterator<C>(x, it);
}

}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 297 "/usr/include/boost/move/iterator.hpp" 2 3 4
# 23 "/usr/include/boost/move/move.hpp" 2 3 4
# 1 "/usr/include/boost/move/traits.hpp" 1 3 4
# 17 "/usr/include/boost/move/traits.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/move/traits.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 19 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 2 3 4

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: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 48 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 2 3 4
# 19 "/usr/include/boost/move/traits.hpp" 2 3 4






namespace boost {
# 36 "/usr/include/boost/move/traits.hpp" 3 4
template <class T>
struct has_trivial_destructor_after_move
   : ::boost::has_trivial_destructor<T>
{};



template <class T>
struct has_nothrow_move
   : public ::boost::move_detail::integral_constant<bool, false>
{};

namespace move_detail {






   template< class T>
   struct forward_type
   { typedef const T &type; };

   template< class T>
   struct forward_type< boost::rv<T> >
   { typedef T type; };


template< class T > struct is_rvalue_reference : ::boost::move_detail::integral_constant<bool, false> { };



   template< class T > struct is_rvalue_reference< boost::rv<T>& >
      : ::boost::move_detail::integral_constant<bool, true>
   {};

   template< class T > struct is_rvalue_reference< const boost::rv<T>& >
      : ::boost::move_detail::integral_constant<bool, true>
   {};





   namespace detail_add_rvalue_reference
   {
      template< class T
              , bool emulation = ::boost::has_move_emulation_enabled<T>::value
              , bool rv = ::boost::move_detail::is_rv<T>::value >
      struct add_rvalue_reference_impl { typedef T type; };

      template< class T, bool emulation>
      struct add_rvalue_reference_impl< T, emulation, true > { typedef T & type; };

      template< class T, bool rv >
      struct add_rvalue_reference_impl< T, true, rv > { typedef ::boost::rv<T>& type; };
   }

   template< class T >
   struct add_rvalue_reference
      : detail_add_rvalue_reference::add_rvalue_reference_impl<T>
   { };

   template< class T >
   struct add_rvalue_reference<T &>
   { typedef T & type; };



template< class T > struct remove_rvalue_reference { typedef T type; };




   template< class T > struct remove_rvalue_reference< rv<T> > { typedef T type; };
   template< class T > struct remove_rvalue_reference< const rv<T> > { typedef T type; };
   template< class T > struct remove_rvalue_reference< volatile rv<T> > { typedef T type; };
   template< class T > struct remove_rvalue_reference< const volatile rv<T> > { typedef T type; };
   template< class T > struct remove_rvalue_reference< rv<T>& > { typedef T type; };
   template< class T > struct remove_rvalue_reference< const rv<T>& > { typedef T type; };
   template< class T > struct remove_rvalue_reference< volatile rv<T>& > { typedef T type; };
   template< class T > struct remove_rvalue_reference< const volatile rv<T>& >{ typedef T type; };


template <typename T>
typename boost::move_detail::add_rvalue_reference<T>::type declval();

}
# 138 "/usr/include/boost/move/traits.hpp" 3 4
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 141 "/usr/include/boost/move/traits.hpp" 2 3 4
# 24 "/usr/include/boost/move/move.hpp" 2 3 4
# 1 "/usr/include/boost/move/algorithm.hpp" 1 3 4
# 17 "/usr/include/boost/move/algorithm.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/move/algorithm.hpp" 2 3 4



# 1 "/usr/include/boost/move/algorithm.hpp" 1 3 4
# 22 "/usr/include/boost/move/algorithm.hpp" 2 3 4
# 1 "/usr/include/boost/detail/no_exceptions_support.hpp" 1 3 4
# 23 "/usr/include/boost/move/algorithm.hpp" 2 3 4




namespace boost {
# 46 "/usr/include/boost/move/algorithm.hpp" 3 4
   template <typename I,
            typename O>
   O move(I f, I l, O result)
   {
      while (f != l) {
         *result = ::boost::move(*f);
         ++f; ++result;
      }
      return result;
   }
# 73 "/usr/include/boost/move/algorithm.hpp" 3 4
   template <typename I,
   typename O>
   O move_backward(I f, I l, O result)
   {
      while (f != l) {
         --l; --result;
         *result = ::boost::move(*l);
      }
      return result;
   }
# 104 "/usr/include/boost/move/algorithm.hpp" 3 4
template
   <typename I,
    typename F>
F uninitialized_move(I f, I l, F r



   )
{
   typedef typename std::iterator_traits<I>::value_type input_value_type;

   F back = r;
   { try{
      while (f != l) {
         void * const addr = static_cast<void*>(::boost::move_detail::addressof(*r));
         ::new(addr) input_value_type(::boost::move(*f));
         ++f; ++r;
      }
   }
   catch(...){
    for (; back != r; ++back){
         back->~input_value_type();
      }
    throw;;
   }
   }
   return r;
}
# 151 "/usr/include/boost/move/algorithm.hpp" 3 4
namespace move_detail {

template
<typename I,
typename F>
inline F uninitialized_move_move_iterator(I f, I l, F r

)
{
   return ::boost::uninitialized_move(f, l, r);
}
# 172 "/usr/include/boost/move/algorithm.hpp" 3 4
}

template
<typename I,
typename F>
inline F uninitialized_copy_or_move(I f, I l, F r,
                             typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0)
{
   return ::boost::move_detail::uninitialized_move_move_iterator(f, l, r);
}







namespace move_detail {

template
<typename I,
typename F>
inline F move_move_iterator(I f, I l, F r

)
{
   return ::boost::move(f, l, r);
}
# 211 "/usr/include/boost/move/algorithm.hpp" 3 4
}

template
<typename I,
typename F>
inline F copy_or_move(I f, I l, F r,
                             typename ::boost::move_detail::enable_if< move_detail::is_move_iterator<I> >::type* = 0)
{
   return ::boost::move_detail::move_move_iterator(f, l, r);
}
# 236 "/usr/include/boost/move/algorithm.hpp" 3 4
template
<typename I,
typename F>
inline F uninitialized_copy_or_move(I f, I l, F r

   ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0

   )
{
   return std::uninitialized_copy(f, l, r);
}
# 259 "/usr/include/boost/move/algorithm.hpp" 3 4
template
<typename I,
typename F>
inline F copy_or_move(I f, I l, F r

   ,typename ::boost::move_detail::disable_if< move_detail::is_move_iterator<I> >::type* = 0

   )
{
   return std::copy(f, l, r);
}

}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 274 "/usr/include/boost/move/algorithm.hpp" 2 3 4
# 25 "/usr/include/boost/move/move.hpp" 2 3 4
# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 26 "/usr/include/boost/move/move.hpp" 2 3 4
# 20 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/size.hpp" 1 3 4
# 21 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/enum.hpp" 1 3 4
# 22 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4
# 1 "/usr/include/boost/swap.hpp" 1 3 4
# 23 "/usr/include/boost/unordered/detail/util.hpp" 2 3 4

namespace boost { namespace unordered { namespace detail {

    static const float minimum_max_load_factor = 1e-3f;
    static const std::size_t default_bucket_count = 11;
    struct move_tag {};
    struct empty_emplace {};




    template <typename I>
    struct is_forward :
        boost::is_convertible<
            typename boost::iterator_traversal<I>::type,
            boost::forward_traversal_tag>
    {};

    template <typename I, typename ReturnType>
    struct enable_if_forward :
        boost::enable_if_c<
            boost::unordered::detail::is_forward<I>::value,
            ReturnType>
    {};

    template <typename I, typename ReturnType>
    struct disable_if_forward :
        boost::disable_if_c<
            boost::unordered::detail::is_forward<I>::value,
            ReturnType>
    {};
# 67 "/usr/include/boost/unordered/detail/util.hpp" 3 4
    template<class T> struct prime_list_template
    {
        static std::size_t const value[];


        static std::ptrdiff_t const length;




    };

    template<class T>
    std::size_t const prime_list_template<T>::value[] = {
        17ul, 29ul, 37ul, 53ul, 67ul, 79ul, 97ul, 131ul, 193ul, 257ul, 389ul, 521ul, 769ul, 1031ul, 1543ul, 2053ul, 3079ul, 6151ul, 12289ul, 24593ul, 49157ul, 98317ul, 196613ul, 393241ul, 786433ul, 1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul, 50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul, 1610612741ul, 3221225473ul, 4294967291ul
    };


    template<class T>
    std::ptrdiff_t const prime_list_template<T>::length
        = 38;




    typedef prime_list_template<std::size_t> prime_list;


    inline std::size_t next_prime(std::size_t num) {
        std::size_t const* const prime_list_begin = prime_list::value;
        std::size_t const* const prime_list_end = prime_list_begin +
            prime_list::length;
        std::size_t const* bound =
            std::lower_bound(prime_list_begin, prime_list_end, num);
        if(bound == prime_list_end)
            bound--;
        return *bound;
    }


    inline std::size_t prev_prime(std::size_t num) {
        std::size_t const* const prime_list_begin = prime_list::value;
        std::size_t const* const prime_list_end = prime_list_begin +
            prime_list::length;
        std::size_t const* bound =
            std::upper_bound(prime_list_begin,prime_list_end, num);
        if(bound != prime_list_begin)
            bound--;
        return *bound;
    }






    using ::std::distance;
# 136 "/usr/include/boost/unordered/detail/util.hpp" 3 4
    template <class I>
    inline typename
        boost::unordered::detail::enable_if_forward<I, std::size_t>::type
        insert_size(I i, I j)
    {
        return std::distance(i, j);
    }

    template <class I>
    inline typename
        boost::unordered::detail::disable_if_forward<I, std::size_t>::type
        insert_size(I, I)
    {
        return 1;
    }

    template <class I>
    inline std::size_t initial_size(I i, I j,
        std::size_t num_buckets =
            boost::unordered::detail::default_bucket_count)
    {

        return (std::max)(
            boost::unordered::detail::insert_size(i, j) + 1,
            num_buckets);
    }




    template <typename T, int Index>
    struct compressed_base : private T
    {
        compressed_base(T const& x) : T(x) {}
        compressed_base(T& x, move_tag) : T(boost::move(x)) {}

        T& get() { return *this; }
        T const& get() const { return *this; }
    };

    template <typename T, int Index>
    struct uncompressed_base
    {
        uncompressed_base(T const& x) : value_(x) {}
        uncompressed_base(T& x, move_tag) : value_(boost::move(x)) {}

        T& get() { return value_; }
        T const& get() const { return value_; }
    private:
        T value_;
    };

    template <typename T, int Index>
    struct generate_base
      : boost::detail::if_true<
            boost::is_empty<T>::value
        >:: template then<
            boost::unordered::detail::compressed_base<T, Index>,
            boost::unordered::detail::uncompressed_base<T, Index>
        >
    {};

    template <typename T1, typename T2>
    struct compressed
      : private boost::unordered::detail::generate_base<T1, 1>::type,
        private boost::unordered::detail::generate_base<T2, 2>::type
    {
        typedef typename generate_base<T1, 1>::type base1;
        typedef typename generate_base<T2, 2>::type base2;

        typedef T1 first_type;
        typedef T2 second_type;

        first_type& first() {
            return static_cast<base1*>(this)->get();
        }

        first_type const& first() const {
            return static_cast<base1 const*>(this)->get();
        }

        second_type& second() {
            return static_cast<base2*>(this)->get();
        }

        second_type const& second() const {
            return static_cast<base2 const*>(this)->get();
        }

        template <typename First, typename Second>
        compressed(First const& x1, Second const& x2)
            : base1(x1), base2(x2) {}

        compressed(compressed const& x)
            : base1(x.first()), base2(x.second()) {}

        compressed(compressed& x, move_tag m)
            : base1(x.first(), m), base2(x.second(), m) {}

        void assign(compressed const& x)
        {
            first() = x.first();
            second() = x.second();
        }

        void move_assign(compressed& x)
        {
            first() = boost::move(x.first());
            second() = boost::move(x.second());
        }

        void swap(compressed& x)
        {
            boost::swap(first(), x.first());
            boost::swap(second(), x.second());
        }

    private:


        compressed& operator=(compressed const&);
    };
}}}
# 15 "/usr/include/boost/unordered/detail/buckets.hpp" 2 3 4
# 1 "/usr/include/boost/unordered/detail/allocate.hpp" 1 3 4
# 20 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/dec.hpp" 1 3 4
# 21 "/usr/include/boost/unordered/detail/allocate.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3 4
# 23 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
# 25 "/usr/include/boost/unordered/detail/allocate.hpp" 2 3 4


# 1 "/usr/include/boost/tuple/tuple.hpp" 1 3 4
# 32 "/usr/include/boost/tuple/tuple.hpp" 3 4
# 1 "/usr/include/boost/ref.hpp" 1 3 4
# 29 "/usr/include/boost/ref.hpp" 3 4
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;
};
# 106 "/usr/include/boost/ref.hpp" 3 4
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; };
# 176 "/usr/include/boost/ref.hpp" 3 4
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();
}

}
# 33 "/usr/include/boost/tuple/tuple.hpp" 2 3 4
# 1 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 1 3 4
# 38 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
# 1 "/usr/include/boost/type_traits/cv_traits.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/cv_traits.hpp" 3 4
# 1 "/usr/include/boost/type_traits/add_const.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/add_const.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4

namespace boost {
# 33 "/usr/include/boost/type_traits/add_const.hpp" 3 4
template< typename T > struct add_const { public: typedef T const type; };






template< typename T > struct add_const<T&> { public: typedef T& type; };


}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 46 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_volatile.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/add_volatile.hpp" 2 3 4

namespace boost {
# 33 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
template< typename T > struct add_volatile { public: typedef T volatile type; };






template< typename T > struct add_volatile<T&> { public: typedef T& type; };


}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 46 "/usr/include/boost/type_traits/add_volatile.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_cv.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/add_cv.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/add_cv.hpp" 2 3 4

namespace boost {
# 34 "/usr/include/boost/type_traits/add_cv.hpp" 3 4
template< typename T > struct add_cv { public: typedef T const volatile type; };






template< typename T > struct add_cv<T&> { public: typedef T& type; };


}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 47 "/usr/include/boost/type_traits/add_cv.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_const.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/is_const.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 44 "/usr/include/boost/type_traits/is_const.hpp" 2 3 4

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: };
# 160 "/usr/include/boost/type_traits/is_const.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 163 "/usr/include/boost/type_traits/is_const.hpp" 2 3 4
# 19 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/remove_const.hpp" 1 3 4
# 20 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 21 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 28 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4

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;
};
# 69 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
}



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]; };
# 86 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 89 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_volatile.hpp" 1 3 4
# 20 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 21 "/usr/include/boost/type_traits/remove_volatile.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 28 "/usr/include/boost/type_traits/remove_volatile.hpp" 2 3 4

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;
};
# 67 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
}



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]; };
# 84 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 87 "/usr/include/boost/type_traits/remove_volatile.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/cv_traits.hpp" 2 3 4
# 39 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/function_traits.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/function_traits.hpp" 3 4
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>
{
};
# 234 "/usr/include/boost/type_traits/function_traits.hpp" 3 4
}
# 40 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 2 3 4




namespace boost {
namespace tuples {


struct null_type {};


namespace detail {
  inline const null_type cnull() { return null_type(); }





template <bool If, class Then, class Else> struct IF { typedef Then RET; };

template <class Then, class Else> struct IF<false, Then, Else> {
  typedef Else RET;
};

}


template <class HT, class TT> struct cons;



template <
  class T0 = null_type, class T1 = null_type, class T2 = null_type,
  class T3 = null_type, class T4 = null_type, class T5 = null_type,
  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type>
class tuple;


template<class T> struct length;



namespace detail {



template<class T>
class generate_error;

template<int N>
struct drop_front {
    template<class Tuple>
    struct apply {
        typedef typename drop_front<N-1>::template
            apply<Tuple> next;
        typedef typename next::type::tail_type type;
        static const type& call(const Tuple& tup) {
            return next::call(tup).tail;
        }
    };
};

template<>
struct drop_front<0> {
    template<class Tuple>
    struct apply {
        typedef Tuple type;
        static const type& call(const Tuple& tup) {
            return tup;
        }
    };
};

}
# 124 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template<int N, class T>
struct element
{
  typedef typename detail::drop_front<N>::template
      apply<T>::type::head_type type;
};

template<int N, class T>
struct element<N, const T>
{
private:
  typedef typename detail::drop_front<N>::template
      apply<T>::type::head_type unqualified_type;
public:



  typedef typename boost::add_const<unqualified_type>::type type;

};
# 184 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template <class T> struct access_traits {
  typedef const T& const_type;
  typedef T& non_const_type;

  typedef const typename boost::remove_cv<T>::type& parameter_type;






};

template <class T> struct access_traits<T&> {

  typedef T& const_type;
  typedef T& non_const_type;

  typedef T& parameter_type;
};



template<int N, class HT, class TT>
inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::non_const_type
get(cons<HT, TT>& c ) {
  typedef typename detail::drop_front<N>::template
      apply<cons<HT, TT> > impl;
  typedef typename impl::type cons_element;
  return const_cast<cons_element&>(impl::call(c)).head;
}




template<int N, class HT, class TT>
inline typename access_traits<
                  typename element<N, cons<HT, TT> >::type
                >::const_type
get(const cons<HT, TT>& c ) {
  typedef typename detail::drop_front<N>::template
      apply<cons<HT, TT> > impl;
  typedef typename impl::type cons_element;
  return impl::call(c).head;
}


namespace detail {







template <class T> class non_storeable_type {
  non_storeable_type();
};

template <class T> struct wrap_non_storeable_type {
  typedef typename IF<
    ::boost::is_function<T>::value, non_storeable_type<T>, T
  >::RET type;
};
template <> struct wrap_non_storeable_type<void> {
  typedef non_storeable_type<void> type;
};

}

template <class HT, class TT>
struct cons {

  typedef HT head_type;
  typedef TT tail_type;

  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;

  stored_head_type head;
  tail_type tail;

  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

  typename access_traits<tail_type>::non_const_type
  get_tail() { return tail; }

  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }

  typename access_traits<tail_type>::const_type
  get_tail() const { return tail; }

  cons() : head(), tail() {}







  cons(typename access_traits<stored_head_type>::parameter_type h,
       const tail_type& t)
    : head (h), tail(t) {}

  template <class T1, class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
    : head (t1),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}

  template <class T2, class T3, class T4, class T5,
            class T6, class T7, class T8, class T9, class T10>
  cons( const null_type& , T2& t2, T3& t3, T4& t4, T5& t5,
        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
    : head (),
      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
      {}


  template <class HT2, class TT2>
  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

  template <class HT2, class TT2>
  cons& operator=( const cons<HT2, TT2>& u ) {
    head=u.head; tail=u.tail; return *this;
  }



  cons& operator=(const cons& u) {
    head = u.head; tail = u.tail; return *this;
  }

  template <class T1, class T2>
  cons& operator=( const std::pair<T1, T2>& u ) {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((length<cons>::value == 2) == 0 ? false : true) >)> boost_static_assert_typedef_325;
    head = u.first; tail.head = u.second; return *this;
  }


  template <int N>
  typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::non_const_type
  get() {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
             typename element<N, cons<HT, TT> >::type
           >::const_type
  get() const {
    return boost::tuples::get<N>(*this);
  }
};

template <class HT>
struct cons<HT, null_type> {

  typedef HT head_type;
  typedef null_type tail_type;
  typedef cons<HT, null_type> self_type;

  typedef typename
    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
  stored_head_type head;

  typename access_traits<stored_head_type>::non_const_type
  get_head() { return head; }

  null_type get_tail() { return null_type(); }

  typename access_traits<stored_head_type>::const_type
  get_head() const { return head; }

  const null_type get_tail() const { return null_type(); }


  cons() : head() {}

  cons(typename access_traits<stored_head_type>::parameter_type h,
       const null_type& = null_type())
    : head (h) {}

  template<class T1>
  cons(T1& t1, const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head (t1) {}

  cons(const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&,
       const null_type&, const null_type&, const null_type&)
  : head () {}

  template <class HT2>
  cons( const cons<HT2, null_type>& u ) : head(u.head) {}

  template <class HT2>
  cons& operator=(const cons<HT2, null_type>& u )
  { head = u.head; return *this; }



  cons& operator=(const cons& u) { head = u.head; return *this; }

  template <int N>
  typename access_traits<
             typename element<N, self_type>::type
            >::non_const_type
  get() {
    return boost::tuples::get<N>(*this);
  }

  template <int N>
  typename access_traits<
             typename element<N, self_type>::type
           >::const_type
  get() const {
    return boost::tuples::get<N>(*this);
  }

};



template<class T>
struct length {
  static const int value = 1 + length<typename T::tail_type>::value;
};

template<>
struct length<tuple<> > {
  static const int value = 0;
};

template<>
struct length<tuple<> const> {
  static const int value = 0;
};

template<>
struct length<null_type> {
  static const int value = 0;
};

template<>
struct length<null_type const> {
  static const int value = 0;
};

namespace detail {


template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
struct map_tuple_to_cons
{
  typedef cons<T0,
               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
                                          T6, T7, T8, T9, null_type>::type
              > type;
};


template <>
struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
{
  typedef null_type type;
};

}



template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>

class tuple :
  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
{
public:
  typedef typename
    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
  typedef typename inherited::head_type head_type;
  typedef typename inherited::tail_type tail_type;



  tuple() {}

  tuple(typename access_traits<T0>::parameter_type t0)
    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1)
    : inherited(t0, t1, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2)
    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3)
    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4)
    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5)
    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6)
    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
                detail::cnull(), detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
                detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7,
        typename access_traits<T8>::parameter_type t8)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}

  tuple(typename access_traits<T0>::parameter_type t0,
        typename access_traits<T1>::parameter_type t1,
        typename access_traits<T2>::parameter_type t2,
        typename access_traits<T3>::parameter_type t3,
        typename access_traits<T4>::parameter_type t4,
        typename access_traits<T5>::parameter_type t5,
        typename access_traits<T6>::parameter_type t6,
        typename access_traits<T7>::parameter_type t7,
        typename access_traits<T8>::parameter_type t8,
        typename access_traits<T9>::parameter_type t9)
    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}


  template<class U1, class U2>
  tuple(const cons<U1, U2>& p) : inherited(p) {}

  template <class U1, class U2>
  tuple& operator=(const cons<U1, U2>& k) {
    inherited::operator=(k);
    return *this;
  }

  template <class U1, class U2>
  tuple& operator=(const std::pair<U1, U2>& k) {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((length<tuple>::value == 2) == 0 ? false : true) >)> boost_static_assert_typedef_582;
    this->head = k.first;
    this->tail.head = k.second;
    return *this;
  }

};


template <>
class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
  public null_type
{
public:
  typedef null_type inherited;
};



namespace detail {

struct swallow_assign;
typedef void (detail::swallow_assign::*ignore_t)();
struct swallow_assign {
  swallow_assign(ignore_t(*)(ignore_t)) {}
  template<typename T>
  swallow_assign const& operator=(const T&) const {
    return *this;
  }
};


}


inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
# 636 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template<class T>
struct make_tuple_traits {
  typedef T type;







};
# 660 "/usr/include/boost/tuple/detail/tuple_basic.hpp" 3 4
template<class T>
struct make_tuple_traits<T&> {
  typedef typename
     detail::generate_error<T&>::
       do_not_use_with_reference_type error;
};





template<class T, int n> struct make_tuple_traits <T[n]> {
  typedef const T (&type)[n];
};

template<class T, int n>
struct make_tuple_traits<const T[n]> {
  typedef const T (&type)[n];
};

template<class T, int n> struct make_tuple_traits<volatile T[n]> {
  typedef const volatile T (&type)[n];
};

template<class T, int n>
struct make_tuple_traits<const volatile T[n]> {
  typedef const volatile T (&type)[n];
};

template<class T>
struct make_tuple_traits<reference_wrapper<T> >{
  typedef T& type;
};

template<class T>
struct make_tuple_traits<const reference_wrapper<T> >{
  typedef T& type;
};

template<>
struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
  typedef detail::swallow_assign type;
};



namespace detail {



template <
  class T0 = null_type, class T1 = null_type, class T2 = null_type,
  class T3 = null_type, class T4 = null_type, class T5 = null_type,
  class T6 = null_type, class T7 = null_type, class T8 = null_type,
  class T9 = null_type
>
struct make_tuple_mapper {
  typedef
    tuple<typename make_tuple_traits<T0>::type,
          typename make_tuple_traits<T1>::type,
          typename make_tuple_traits<T2>::type,
          typename make_tuple_traits<T3>::type,
          typename make_tuple_traits<T4>::type,
          typename make_tuple_traits<T5>::type,
          typename make_tuple_traits<T6>::type,
          typename make_tuple_traits<T7>::type,
          typename make_tuple_traits<T8>::type,
          typename make_tuple_traits<T9>::type> type;
};

}


inline tuple<> make_tuple() {
  return tuple<>();
}

template<class T0>
inline typename detail::make_tuple_mapper<T0>::type
make_tuple(const T0& t0) {
  typedef typename detail::make_tuple_mapper<T0>::type t;
  return t(t0);
}

template<class T0, class T1>
inline typename detail::make_tuple_mapper<T0, T1>::type
make_tuple(const T0& t0, const T1& t1) {
  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
  return t(t0, t1);
}

template<class T0, class T1, class T2>
inline typename detail::make_tuple_mapper<T0, T1, T2>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
  return t(t0, t1, t2);
}

template<class T0, class T1, class T2, class T3>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
  return t(t0, t1, t2, t3);
}

template<class T0, class T1, class T2, class T3, class T4>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
  return t(t0, t1, t2, t3, t4);
}

template<class T0, class T1, class T2, class T3, class T4, class T5>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5) {
  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
  return t(t0, t1, t2, t3, t4, t5);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7>
inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8>
inline typename detail::make_tuple_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                  const T8& t8) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8, class T9>
inline typename detail::make_tuple_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
                  const T8& t8, const T9& t9) {
  typedef typename detail::make_tuple_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
}

namespace detail {

template<class T>
struct tie_traits {
  typedef T& type;
};

template<>
struct tie_traits<ignore_t(ignore_t)> {
  typedef swallow_assign type;
};

template<>
struct tie_traits<void> {
  typedef null_type type;
};

template <
  class T0 = void, class T1 = void, class T2 = void,
  class T3 = void, class T4 = void, class T5 = void,
  class T6 = void, class T7 = void, class T8 = void,
  class T9 = void
>
struct tie_mapper {
  typedef
    tuple<typename tie_traits<T0>::type,
          typename tie_traits<T1>::type,
          typename tie_traits<T2>::type,
          typename tie_traits<T3>::type,
          typename tie_traits<T4>::type,
          typename tie_traits<T5>::type,
          typename tie_traits<T6>::type,
          typename tie_traits<T7>::type,
          typename tie_traits<T8>::type,
          typename tie_traits<T9>::type> type;
};

}


template<class T0>
inline typename detail::tie_mapper<T0>::type
tie(T0& t0) {
  typedef typename detail::tie_mapper<T0>::type t;
  return t(t0);
}

template<class T0, class T1>
inline typename detail::tie_mapper<T0, T1>::type
tie(T0& t0, T1& t1) {
  typedef typename detail::tie_mapper<T0, T1>::type t;
  return t(t0, t1);
}

template<class T0, class T1, class T2>
inline typename detail::tie_mapper<T0, T1, T2>::type
tie(T0& t0, T1& t1, T2& t2) {
  typedef typename detail::tie_mapper<T0, T1, T2>::type t;
  return t(t0, t1, t2);
}

template<class T0, class T1, class T2, class T3>
inline typename detail::tie_mapper<T0, T1, T2, T3>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3) {
  typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
  return t(t0, t1, t2, t3);
}

template<class T0, class T1, class T2, class T3, class T4>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4) {
  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
  return t(t0, t1, t2, t3, t4);
}

template<class T0, class T1, class T2, class T3, class T4, class T5>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5) {
  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
  return t(t0, t1, t2, t3, t4, t5);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7>
inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6, T7& t7) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8>
inline typename detail::tie_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6, T7& t7,
                  T8& t8) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
}

template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
         class T7, class T8, class T9>
inline typename detail::tie_mapper
  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
tie(T0& t0, T1& t1, T2& t2, T3& t3,
                  T4& t4, T5& t5, T6& t6, T7& t7,
                  T8& t8, T9& t9) {
  typedef typename detail::tie_mapper
           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
}

template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
inline void swap(null_type&, null_type&) {}
template<class HH>
inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
  ::boost::swap(lhs.head, rhs.head);
}
template<class HH, class TT>
inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
  ::boost::swap(lhs.head, rhs.head);
  ::boost::tuples::swap(lhs.tail, rhs.tail);
}
template <class T0, class T1, class T2, class T3, class T4,
          class T5, class T6, class T7, class T8, class T9>
inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
  typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
  typedef typename tuple_type::inherited base;
  ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
}

}
}
# 34 "/usr/include/boost/tuple/tuple.hpp" 2 3 4



namespace boost {

using tuples::tuple;
using tuples::make_tuple;
using tuples::tie;

using tuples::get;
# 87 "/usr/include/boost/tuple/tuple.hpp" 3 4
}
# 28 "/usr/include/boost/unordered/detail/allocate.hpp" 2 3 4



# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 32 "/usr/include/boost/unordered/detail/allocate.hpp" 2 3 4
# 48 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
namespace boost { namespace unordered { namespace detail {




    template <typename T> typename boost::add_lvalue_reference<T>::type make();
    struct choice9 { typedef char (&type)[9]; };
    struct choice8 : choice9 { typedef char (&type)[8]; };
    struct choice7 : choice8 { typedef char (&type)[7]; };
    struct choice6 : choice7 { typedef char (&type)[6]; };
    struct choice5 : choice6 { typedef char (&type)[5]; };
    struct choice4 : choice5 { typedef char (&type)[4]; };
    struct choice3 : choice4 { typedef char (&type)[3]; };
    struct choice2 : choice3 { typedef char (&type)[2]; };
    struct choice1 : choice2 { typedef char (&type)[1]; };
    choice1 choose();

    typedef choice1::type yes_type;
    typedef choice2::type no_type;

    struct private_type
    {
       private_type const &operator,(int) const;
    };

    template <typename T>
    no_type is_private_type(T const&);
    yes_type is_private_type(private_type const&);

    struct convert_from_anything {
        template <typename T>
        convert_from_anything(T const&);
    };
# 161 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
template < typename A0> struct emplace_args1 { typedef const A0 & Arg0; Arg0 a0; emplace_args1 ( Arg0 b0 ) : a0( boost::forward<A0>(b0)) {} }; template < typename A0> inline emplace_args1 < A0 > create_emplace_args( const A0 & b0 ) { emplace_args1 < A0 > e( b0); return e; } template < typename A0 , typename A1> struct emplace_args2 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; emplace_args2 ( Arg0 b0 , Arg1 b1 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) {} }; template < typename A0 , typename A1> inline emplace_args2 < A0 , A1 > create_emplace_args( const A0 & b0 , const A1 & b1 ) { emplace_args2 < A0 , A1 > e( b0 , b1); return e; } template < typename A0 , typename A1 , typename A2> struct emplace_args3 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; emplace_args3 ( Arg0 b0 , Arg1 b1 , Arg2 b2 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) {} }; template < typename A0 , typename A1 , typename A2> inline emplace_args3 < A0 , A1 , A2 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 ) { emplace_args3 < A0 , A1 , A2 > e( b0 , b1 , b2); return e; } template < typename A0 , typename A1 , typename A2 , typename A3> struct emplace_args4 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; typedef const A3 & Arg3; Arg3 a3; emplace_args4 ( Arg0 b0 , Arg1 b1 , Arg2 b2 , Arg3 b3 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) , a3( boost::forward<A3>(b3)) {} }; template < typename A0 , typename A1 , typename A2 , typename A3> inline emplace_args4 < A0 , A1 , A2 , A3 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 , const A3 & b3 ) { emplace_args4 < A0 , A1 , A2 , A3 > e( b0 , b1 , b2 , b3); return e; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4> struct emplace_args5 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; typedef const A3 & Arg3; Arg3 a3; typedef const A4 & Arg4; Arg4 a4; emplace_args5 ( Arg0 b0 , Arg1 b1 , Arg2 b2 , Arg3 b3 , Arg4 b4 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) , a3( boost::forward<A3>(b3)) , a4( boost::forward<A4>(b4)) {} }; template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4> inline emplace_args5 < A0 , A1 , A2 , A3 , A4 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 , const A3 & b3 , const A4 & b4 ) { emplace_args5 < A0 , A1 , A2 , A3 , A4 > e( b0 , b1 , b2 , b3 , b4); return e; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> struct emplace_args6 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; typedef const A3 & Arg3; Arg3 a3; typedef const A4 & Arg4; Arg4 a4; typedef const A5 & Arg5; Arg5 a5; emplace_args6 ( Arg0 b0 , Arg1 b1 , Arg2 b2 , Arg3 b3 , Arg4 b4 , Arg5 b5 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) , a3( boost::forward<A3>(b3)) , a4( boost::forward<A4>(b4)) , a5( boost::forward<A5>(b5)) {} }; template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> inline emplace_args6 < A0 , A1 , A2 , A3 , A4 , A5 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 , const A3 & b3 , const A4 & b4 , const A5 & b5 ) { emplace_args6 < A0 , A1 , A2 , A3 , A4 , A5 > e( b0 , b1 , b2 , b3 , b4 , b5); return e; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> struct emplace_args7 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; typedef const A3 & Arg3; Arg3 a3; typedef const A4 & Arg4; Arg4 a4; typedef const A5 & Arg5; Arg5 a5; typedef const A6 & Arg6; Arg6 a6; emplace_args7 ( Arg0 b0 , Arg1 b1 , Arg2 b2 , Arg3 b3 , Arg4 b4 , Arg5 b5 , Arg6 b6 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) , a3( boost::forward<A3>(b3)) , a4( boost::forward<A4>(b4)) , a5( boost::forward<A5>(b5)) , a6( boost::forward<A6>(b6)) {} }; template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> inline emplace_args7 < A0 , A1 , A2 , A3 , A4 , A5 , A6 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 , const A3 & b3 , const A4 & b4 , const A5 & b5 , const A6 & b6 ) { emplace_args7 < A0 , A1 , A2 , A3 , A4 , A5 , A6 > e( b0 , b1 , b2 , b3 , b4 , b5 , b6); return e; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> struct emplace_args8 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; typedef const A3 & Arg3; Arg3 a3; typedef const A4 & Arg4; Arg4 a4; typedef const A5 & Arg5; Arg5 a5; typedef const A6 & Arg6; Arg6 a6; typedef const A7 & Arg7; Arg7 a7; emplace_args8 ( Arg0 b0 , Arg1 b1 , Arg2 b2 , Arg3 b3 , Arg4 b4 , Arg5 b5 , Arg6 b6 , Arg7 b7 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) , a3( boost::forward<A3>(b3)) , a4( boost::forward<A4>(b4)) , a5( boost::forward<A5>(b5)) , a6( boost::forward<A6>(b6)) , a7( boost::forward<A7>(b7)) {} }; template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> inline emplace_args8 < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 , const A3 & b3 , const A4 & b4 , const A5 & b5 , const A6 & b6 , const A7 & b7 ) { emplace_args8 < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > e( b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7); return e; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> struct emplace_args9 { typedef const A0 & Arg0; Arg0 a0; typedef const A1 & Arg1; Arg1 a1; typedef const A2 & Arg2; Arg2 a2; typedef const A3 & Arg3; Arg3 a3; typedef const A4 & Arg4; Arg4 a4; typedef const A5 & Arg5; Arg5 a5; typedef const A6 & Arg6; Arg6 a6; typedef const A7 & Arg7; Arg7 a7; typedef const A8 & Arg8; Arg8 a8; emplace_args9 ( Arg0 b0 , Arg1 b1 , Arg2 b2 , Arg3 b3 , Arg4 b4 , Arg5 b5 , Arg6 b6 , Arg7 b7 , Arg8 b8 ) : a0( boost::forward<A0>(b0)) , a1( boost::forward<A1>(b1)) , a2( boost::forward<A2>(b2)) , a3( boost::forward<A3>(b3)) , a4( boost::forward<A4>(b4)) , a5( boost::forward<A5>(b5)) , a6( boost::forward<A6>(b6)) , a7( boost::forward<A7>(b7)) , a8( boost::forward<A8>(b8)) {} }; template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> inline emplace_args9 < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > create_emplace_args( const A0 & b0 , const A1 & b1 , const A2 & b2 , const A3 & b3 , const A4 & b4 , const A5 & b5 , const A6 & b6 , const A7 & b7 , const A8 & b8 ) { emplace_args9 < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > e( b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8); return e; }
# 170 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
}}}
# 206 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
namespace boost { namespace unordered { namespace detail {
# 221 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename T, T Value>
    struct integral_constant { enum { value = Value }; };

    typedef boost::unordered::detail::integral_constant<bool, true> true_type;
    typedef boost::unordered::detail::integral_constant<bool, false> false_type;
# 237 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <class T>
    inline void destroy(T* x) {
        x->~T();
    }
# 258 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename T, unsigned int> struct expr_test;
    template <typename T> struct expr_test<T, sizeof(char)> : T {};
    template <typename U> static char for_expr_test(U const&);
# 328 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
}}}
# 340 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
# 1 "/usr/include/boost/pointer_to_other.hpp" 1 3 4
# 18 "/usr/include/boost/pointer_to_other.hpp" 3 4
namespace boost
{



template<class T, class U>
struct pointer_to_other;

template<class T, class U,
         template<class> class Sp>
struct pointer_to_other< Sp<T>, U >
{
   typedef Sp<U> type;
};

template<class T, class T2, class U,
         template<class, class> class Sp>
struct pointer_to_other< Sp<T, T2>, U >
{
   typedef Sp<U, T2> type;
};

template<class T, class T2, class T3, class U,
         template<class, class, class> class Sp>
struct pointer_to_other< Sp<T, T2, T3>, U >
{
   typedef Sp<U, T2, T3> type;
};

template<class T, class U>
struct pointer_to_other< T*, U >
{
   typedef U* type;
};

}
# 341 "/usr/include/boost/unordered/detail/allocate.hpp" 2 3 4
# 352 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
namespace boost { namespace unordered { namespace detail {


    template <typename Alloc, typename T>
    struct rebind_wrap
    {
        typedef typename Alloc::template rebind<T>::other type;
    };
# 384 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename T, typename T2>
    struct sfinae : T2 {};
# 413 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename Tp, typename Default> struct default_type_pointer { template <typename X> static typename boost::unordered::detail::sfinae< typename X::pointer, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default pointer; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::pointer type; };
    template <typename Tp, typename Default> struct default_type_const_pointer { template <typename X> static typename boost::unordered::detail::sfinae< typename X::const_pointer, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default const_pointer; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::const_pointer type; };
    template <typename Tp, typename Default> struct default_type_void_pointer { template <typename X> static typename boost::unordered::detail::sfinae< typename X::void_pointer, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default void_pointer; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::void_pointer type; };
    template <typename Tp, typename Default> struct default_type_const_void_pointer { template <typename X> static typename boost::unordered::detail::sfinae< typename X::const_void_pointer, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default const_void_pointer; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::const_void_pointer type; };
    template <typename Tp, typename Default> struct default_type_difference_type { template <typename X> static typename boost::unordered::detail::sfinae< typename X::difference_type, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default difference_type; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::difference_type type; };
    template <typename Tp, typename Default> struct default_type_size_type { template <typename X> static typename boost::unordered::detail::sfinae< typename X::size_type, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default size_type; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::size_type type; };
    template <typename Tp, typename Default> struct default_type_propagate_on_container_copy_assignment { template <typename X> static typename boost::unordered::detail::sfinae< typename X::propagate_on_container_copy_assignment, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default propagate_on_container_copy_assignment; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::propagate_on_container_copy_assignment type; };
    template <typename Tp, typename Default> struct default_type_propagate_on_container_move_assignment { template <typename X> static typename boost::unordered::detail::sfinae< typename X::propagate_on_container_move_assignment, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default propagate_on_container_move_assignment; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::propagate_on_container_move_assignment type; };
    template <typename Tp, typename Default> struct default_type_propagate_on_container_swap { template <typename X> static typename boost::unordered::detail::sfinae< typename X::propagate_on_container_swap, choice1>::type test(choice1); template <typename X> static choice2::type test(choice2); struct DefaultWrap { typedef Default propagate_on_container_swap; }; enum { value = (1 == sizeof(test<Tp>(choose()))) }; typedef typename boost::detail::if_true<value>:: template then<Tp, DefaultWrap> ::type::propagate_on_container_swap type; };



    template <typename T>
    struct has_select_on_container_copy_construction { template <typename U> static typename boost::unordered::detail::expr_test< choice1, sizeof(boost::unordered::detail::for_expr_test(( (boost::unordered::detail::make< U const >().select_on_container_copy_construction ()), 0)))>::type test( choice1); template <typename U> static choice2::type test( choice2); enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) }; }

     ;

    template <typename T>
    struct has_max_size { template <typename U> static typename boost::unordered::detail::expr_test< choice1, sizeof(boost::unordered::detail::for_expr_test(( (boost::unordered::detail::make< U const >().max_size ()), 0)))>::type test( choice1); template <typename U> static choice2::type test( choice2); enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) }; }

     ;
# 446 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename T, typename ValueType>
    struct has_construct { template <typename U> static typename boost::unordered::detail::expr_test< choice1, sizeof(boost::unordered::detail::for_expr_test(( (boost::unordered::detail::make< U >().construct ( boost::unordered::detail::make<ValueType*>(), boost::unordered::detail::make<ValueType const>())), 0)))>::type test( choice1); template <typename U> static choice2::type test( choice2); enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) }; }



     ;



    template <typename T, typename ValueType>
    struct has_destroy { template <typename U> static typename boost::unordered::detail::expr_test< choice1, sizeof(boost::unordered::detail::for_expr_test(( (boost::unordered::detail::make< U >().destroy (boost::unordered::detail::make<ValueType*>())), 0)))>::type test( choice1); template <typename U> static choice2::type test( choice2); enum { value = sizeof(test<T>(choose())) == sizeof(choice1::type) }; }

     ;
# 476 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename Alloc>
    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
        typename boost::enable_if_c<
            boost::unordered::detail::
            has_select_on_container_copy_construction<Alloc>::value, void*
        >::type = 0)
    {
        return rhs.select_on_container_copy_construction();
    }

    template <typename Alloc>
    inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
        typename boost::disable_if_c<
            boost::unordered::detail::
            has_select_on_container_copy_construction<Alloc>::value, void*
        >::type = 0)
    {
        return rhs;
    }

    template <typename SizeType, typename Alloc>
    inline SizeType call_max_size(const Alloc& a,
        typename boost::enable_if_c<
            boost::unordered::detail::has_max_size<Alloc>::value, void*
        >::type = 0)
    {
        return a.max_size();
    }

    template <typename SizeType, typename Alloc>
    inline SizeType call_max_size(const Alloc&, typename boost::disable_if_c<
            boost::unordered::detail::has_max_size<Alloc>::value, void*
        >::type = 0)
    {
        return (std::numeric_limits<SizeType>::max)();
    }

    template <typename Alloc>
    struct allocator_traits
    {
        typedef Alloc allocator_type;
        typedef typename Alloc::value_type value_type;

        typedef typename default_type_pointer<Alloc, value_type*>::type
            pointer;

        template <typename T>
        struct pointer_to_other : boost::pointer_to_other<pointer, T> {};

        typedef typename default_type_const_pointer<Alloc, typename pointer_to_other<const value_type>::type>::type

            const_pointer;
# 537 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
        typedef typename default_type_difference_type<Alloc, std::ptrdiff_t>::type
                            difference_type;

        typedef typename default_type_size_type<Alloc, std::size_t>::type
            size_type;



        static pointer allocate(Alloc& a, size_type n)
            { return a.allocate(n); }







        static void deallocate(Alloc& a, pointer p, size_type n)
            { a.deallocate(p, n); }

    public:
# 597 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
        template <typename T>
        static typename boost::enable_if_c<
                boost::unordered::detail::has_construct<Alloc, T>::value>::type
            construct(Alloc& a, T* p, T const& x)
        {
            a.construct(p, x);
        }

        template <typename T>
        static typename boost::disable_if_c<
                boost::unordered::detail::has_construct<Alloc, T>::value>::type
            construct(Alloc&, T* p, T const& x)
        {
            new ((void*) p) T(x);
        }

        template <typename T>
        static typename boost::enable_if_c<
                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
            destroy(Alloc& a, T* p)
        {
            a.destroy(p);
        }

        template <typename T>
        static typename boost::disable_if_c<
                boost::unordered::detail::has_destroy<Alloc, T>::value>::type
            destroy(Alloc&, T* p)
        {
            boost::unordered::detail::destroy(p);
        }
# 677 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
        static size_type max_size(const Alloc& a)
        {
            return boost::unordered::detail::call_max_size<size_type>(a);
        }



        static Alloc select_on_container_copy_construction(Alloc const& rhs)
        {
            return boost::unordered::detail::
                call_select_on_container_copy_construction(rhs);
        }



        typedef typename default_type_propagate_on_container_copy_assignment<Alloc, false_type>::type

            propagate_on_container_copy_assignment;
        typedef typename default_type_propagate_on_container_move_assignment<Alloc, false_type>::type

            propagate_on_container_move_assignment;
        typedef typename default_type_propagate_on_container_swap<Alloc, false_type>::type

            propagate_on_container_swap;
    };
}}}
# 761 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
namespace boost { namespace unordered { namespace detail {
# 803 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename Alloc, typename T>
    inline void destroy_value_impl(Alloc&, T* x) {
        boost::unordered::detail::destroy(x);
    }
# 900 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
template<typename Alloc, typename T> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple<>) { new ((void*) ptr) T(); } template<typename Alloc, typename T, typename A0> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0> const& x) { new ((void*) ptr) T( boost:: get<0>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2 , A3> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) , boost:: get<3>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2 , A3 , A4> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) , boost:: get<3>(x) , boost:: get<4>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2 , A3 , A4 , A5> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) , boost:: get<3>(x) , boost:: get<4>(x) , boost:: get<5>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2 , A3 , A4 , A5 , A6> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) , boost:: get<3>(x) , boost:: get<4>(x) , boost:: get<5>(x) , boost:: get<6>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) , boost:: get<3>(x) , boost:: get<4>(x) , boost:: get<5>(x) , boost:: get<6>(x) , boost:: get<7>(x) ); } template<typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> void construct_from_tuple(Alloc&, T* ptr, boost:: tuple< A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> const& x) { new ((void*) ptr) T( boost:: get<0>(x) , boost:: get<1>(x) , boost:: get<2>(x) , boost:: get<3>(x) , boost:: get<4>(x) , boost:: get<5>(x) , boost:: get<6>(x) , boost:: get<7>(x) , boost:: get<8>(x) ); }
# 926 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename A0>
    struct use_piecewise {
        static choice1::type test(choice1,
            boost::unordered::piecewise_construct_t);

        static choice2::type test(choice2, ...);

        enum { value = sizeof(choice1::type) ==
            sizeof(test(choose(), boost::unordered::detail::make<A0>())) };
    };
# 977 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename Alloc, typename T, typename A0>
    inline void construct_value_impl(Alloc&, T* address,
            emplace_args1<A0> const& args)
    {
        new((void*) address) T(boost::forward<A0>(args.a0));
    }

    template <typename Alloc, typename T, typename A0, typename A1>
    inline void construct_value_impl(Alloc&, T* address,
            emplace_args2<A0, A1> const& args)
    {
        new((void*) address) T(
            boost::forward<A0>(args.a0),
            boost::forward<A1>(args.a1)
        );
    }

    template <typename Alloc, typename T, typename A0, typename A1, typename A2>
    inline void construct_value_impl(Alloc&, T* address,
            emplace_args3<A0, A1, A2> const& args)
    {
        new((void*) address) T(
            boost::forward<A0>(args.a0),
            boost::forward<A1>(args.a1),
            boost::forward<A2>(args.a2)
        );
    }
# 1022 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template < typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 > inline void construct_value_impl(Alloc&, T* address, boost::unordered::detail::emplace_args4 < A0 , A1 , A2 , A3 > const& args) { new((void*) address) T( boost::forward<A0>(args.a0) , boost::forward<A1>(args.a1) , boost::forward<A2>(args.a2) , boost::forward<A3>(args.a3)); } template < typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 > inline void construct_value_impl(Alloc&, T* address, boost::unordered::detail::emplace_args5 < A0 , A1 , A2 , A3 , A4 > const& args) { new((void*) address) T( boost::forward<A0>(args.a0) , boost::forward<A1>(args.a1) , boost::forward<A2>(args.a2) , boost::forward<A3>(args.a3) , boost::forward<A4>(args.a4)); } template < typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > inline void construct_value_impl(Alloc&, T* address, boost::unordered::detail::emplace_args6 < A0 , A1 , A2 , A3 , A4 , A5 > const& args) { new((void*) address) T( boost::forward<A0>(args.a0) , boost::forward<A1>(args.a1) , boost::forward<A2>(args.a2) , boost::forward<A3>(args.a3) , boost::forward<A4>(args.a4) , boost::forward<A5>(args.a5)); } template < typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 > inline void construct_value_impl(Alloc&, T* address, boost::unordered::detail::emplace_args7 < A0 , A1 , A2 , A3 , A4 , A5 , A6 > const& args) { new((void*) address) T( boost::forward<A0>(args.a0) , boost::forward<A1>(args.a1) , boost::forward<A2>(args.a2) , boost::forward<A3>(args.a3) , boost::forward<A4>(args.a4) , boost::forward<A5>(args.a5) , boost::forward<A6>(args.a6)); } template < typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 > inline void construct_value_impl(Alloc&, T* address, boost::unordered::detail::emplace_args8 < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 > const& args) { new((void*) address) T( boost::forward<A0>(args.a0) , boost::forward<A1>(args.a1) , boost::forward<A2>(args.a2) , boost::forward<A3>(args.a3) , boost::forward<A4>(args.a4) , boost::forward<A5>(args.a5) , boost::forward<A6>(args.a6) , boost::forward<A7>(args.a7)); } template < typename Alloc, typename T, typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 > inline void construct_value_impl(Alloc&, T* address, boost::unordered::detail::emplace_args9 < A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 > const& args) { new((void*) address) T( boost::forward<A0>(args.a0) , boost::forward<A1>(args.a1) , boost::forward<A2>(args.a2) , boost::forward<A3>(args.a3) , boost::forward<A4>(args.a4) , boost::forward<A5>(args.a5) , boost::forward<A6>(args.a6) , boost::forward<A7>(args.a7) , boost::forward<A8>(args.a8)); }






    template <typename Alloc, typename A, typename B,
        typename A0, typename A1, typename A2>
    inline void construct_value_impl(Alloc& alloc, std::pair<A, B>* address,
            boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
            typename enable_if<use_piecewise<A0>, void*>::type = 0)
    {
        boost::unordered::detail::construct_from_tuple(alloc,
            boost::addressof(address->first), args.a1);
        boost::unordered::detail::construct_from_tuple(alloc,
            boost::addressof(address->second), args.a2);
    }



}}}





namespace boost { namespace unordered { namespace detail {
# 1059 "/usr/include/boost/unordered/detail/allocate.hpp" 3 4
    template <typename Allocator>
    struct array_constructor
    {
        typedef boost::unordered::detail::allocator_traits<Allocator> traits;
        typedef typename traits::pointer pointer;

        Allocator& alloc_;
        pointer ptr_;
        pointer constructed_;
        std::size_t length_;

        array_constructor(Allocator& a)
            : alloc_(a), ptr_(), constructed_(), length_(0)
        {
            constructed_ = pointer();
            ptr_ = pointer();
        }

        ~array_constructor() {
            if (ptr_) {
                for(pointer p = ptr_; p != constructed_; ++p)
                    traits::destroy(alloc_, boost::addressof(*p));

                traits::deallocate(alloc_, ptr_, length_);
            }
        }

        template <typename V>
        void construct(V const& v, std::size_t l)
        {
            ((!ptr_) ? static_cast<void> (0) : __assert_fail ("!ptr_", "/usr/include/boost/unordered/detail/allocate.hpp", 1089, __PRETTY_FUNCTION__));
            length_ = l;
            ptr_ = traits::allocate(alloc_, length_);
            pointer end = ptr_ + static_cast<std::ptrdiff_t>(length_);
            for(constructed_ = ptr_; constructed_ != end; ++constructed_)
                traits::construct(alloc_, boost::addressof(*constructed_), v);
        }

        pointer get() const
        {
            return ptr_;
        }

        pointer release()
        {
            pointer p(ptr_);
            ptr_ = pointer();
            return p;
        }

    private:

        array_constructor(array_constructor const&);
        array_constructor& operator=(array_constructor const&);
    };
}}}
# 16 "/usr/include/boost/unordered/detail/buckets.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/aligned_storage.hpp" 1 3 4
# 11 "/usr/include/boost/type_traits/aligned_storage.hpp" 3 4
# 1 "/usr/include/boost/aligned_storage.hpp" 1 3 4
# 16 "/usr/include/boost/aligned_storage.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 17 "/usr/include/boost/aligned_storage.hpp" 2 3 4
# 27 "/usr/include/boost/aligned_storage.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 28 "/usr/include/boost/aligned_storage.hpp" 2 3 4

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&);
# 118 "/usr/include/boost/aligned_storage.hpp" 3 4
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();
    }







};
# 168 "/usr/include/boost/aligned_storage.hpp" 3 4
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>
{
   
};



}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 180 "/usr/include/boost/aligned_storage.hpp" 2 3 4
# 12 "/usr/include/boost/type_traits/aligned_storage.hpp" 2 3 4
# 17 "/usr/include/boost/unordered/detail/buckets.hpp" 2 3 4


# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 20 "/usr/include/boost/unordered/detail/buckets.hpp" 2 3 4



namespace boost { namespace unordered { namespace detail {

    template <typename Types> struct table;
    template <typename NodePointer> struct bucket;
    struct ptr_bucket;
    template <typename Types> struct table_impl;
    template <typename Types> struct grouped_table_impl;

}}}

namespace boost { namespace unordered { namespace iterator_detail {






    template <typename Node> struct iterator;
    template <typename Node, typename ConstNodePointer> struct c_iterator;
    template <typename Node, typename Policy> struct l_iterator;
    template <typename Node, typename ConstNodePointer, typename Policy>
        struct cl_iterator;





    template <typename Node, typename Policy>
    struct l_iterator
        : public boost::iterator<
            std::forward_iterator_tag,
            typename Node::value_type,
            std::ptrdiff_t,
            typename Node::node_pointer,
            typename Node::value_type&>
    {

        template <typename Node2, typename ConstNodePointer, typename Policy2>
        friend struct boost::unordered::iterator_detail::cl_iterator;
    private:

        typedef typename Node::node_pointer node_pointer;
        typedef boost::unordered::iterator_detail::iterator<Node> iterator;
        node_pointer ptr_;
        std::size_t bucket_;
        std::size_t bucket_count_;

    public:

        typedef typename Node::value_type value_type;

        l_iterator() : ptr_() {}

        l_iterator(iterator x, std::size_t b, std::size_t c)
            : ptr_(x.node_), bucket_(b), bucket_count_(c) {}

        value_type& operator*() const {
            return ptr_->value();
        }

        value_type* operator->() const {
            return ptr_->value_ptr();
        }

        l_iterator& operator++() {
            ptr_ = static_cast<node_pointer>(ptr_->next_);
            if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_)
                    != bucket_)
                ptr_ = node_pointer();
            return *this;
        }

        l_iterator operator++(int) {
            l_iterator tmp(*this);
            ++(*this);
            return tmp;
        }

        bool operator==(l_iterator x) const {
            return ptr_ == x.ptr_;
        }

        bool operator!=(l_iterator x) const {
            return ptr_ != x.ptr_;
        }
    };

    template <typename Node, typename ConstNodePointer, typename Policy>
    struct cl_iterator
        : public boost::iterator<
            std::forward_iterator_tag,
            typename Node::value_type,
            std::ptrdiff_t,
            ConstNodePointer,
            typename Node::value_type const&>
    {
        friend struct boost::unordered::iterator_detail::l_iterator
            <Node, Policy>;
    private:

        typedef typename Node::node_pointer node_pointer;
        typedef boost::unordered::iterator_detail::iterator<Node> iterator;
        node_pointer ptr_;
        std::size_t bucket_;
        std::size_t bucket_count_;

    public:

        typedef typename Node::value_type value_type;

        cl_iterator() : ptr_() {}

        cl_iterator(iterator x, std::size_t b, std::size_t c) :
            ptr_(x.node_), bucket_(b), bucket_count_(c) {}

        cl_iterator(boost::unordered::iterator_detail::l_iterator<
                Node, Policy> const& x) :
            ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_)
        {}

        value_type const& operator*() const {
            return ptr_->value();
        }

        value_type const* operator->() const {
            return ptr_->value_ptr();
        }

        cl_iterator& operator++() {
            ptr_ = static_cast<node_pointer>(ptr_->next_);
            if (ptr_ && Policy::to_bucket(bucket_count_, ptr_->hash_)
                    != bucket_)
                ptr_ = node_pointer();
            return *this;
        }

        cl_iterator operator++(int) {
            cl_iterator tmp(*this);
            ++(*this);
            return tmp;
        }

        friend bool operator==(cl_iterator const& x, cl_iterator const& y) {
            return x.ptr_ == y.ptr_;
        }

        friend bool operator!=(cl_iterator const& x, cl_iterator const& y) {
            return x.ptr_ != y.ptr_;
        }
    };

    template <typename Node>
    struct iterator
        : public boost::iterator<
            std::forward_iterator_tag,
            typename Node::value_type,
            std::ptrdiff_t,
            typename Node::node_pointer,
            typename Node::value_type&>
    {

        template <typename, typename>
        friend struct boost::unordered::iterator_detail::c_iterator;
        template <typename, typename>
        friend struct boost::unordered::iterator_detail::l_iterator;
        template <typename, typename, typename>
        friend struct boost::unordered::iterator_detail::cl_iterator;
        template <typename>
        friend struct boost::unordered::detail::table;
        template <typename>
        friend struct boost::unordered::detail::table_impl;
        template <typename>
        friend struct boost::unordered::detail::grouped_table_impl;
    private:

        typedef typename Node::node_pointer node_pointer;
        node_pointer node_;

    public:

        typedef typename Node::value_type value_type;

        iterator() : node_() {}

        explicit iterator(typename Node::link_pointer x) :
            node_(static_cast<node_pointer>(x)) {}

        value_type& operator*() const {
            return node_->value();
        }

        value_type* operator->() const {
            return &node_->value();
        }

        iterator& operator++() {
            node_ = static_cast<node_pointer>(node_->next_);
            return *this;
        }

        iterator operator++(int) {
            iterator tmp(node_);
            node_ = static_cast<node_pointer>(node_->next_);
            return tmp;
        }

        bool operator==(iterator const& x) const {
            return node_ == x.node_;
        }

        bool operator!=(iterator const& x) const {
            return node_ != x.node_;
        }
    };

    template <typename Node, typename ConstNodePointer>
    struct c_iterator
        : public boost::iterator<
            std::forward_iterator_tag,
            typename Node::value_type,
            std::ptrdiff_t,
            ConstNodePointer,
            typename Node::value_type const&>
    {
        friend struct boost::unordered::iterator_detail::iterator<Node>;


        template <typename>
        friend struct boost::unordered::detail::table;
        template <typename>
        friend struct boost::unordered::detail::table_impl;
        template <typename>
        friend struct boost::unordered::detail::grouped_table_impl;

    private:

        typedef typename Node::node_pointer node_pointer;
        typedef boost::unordered::iterator_detail::iterator<Node> iterator;
        node_pointer node_;

    public:

        typedef typename Node::value_type value_type;

        c_iterator() : node_() {}

        explicit c_iterator(typename Node::link_pointer x) :
            node_(static_cast<node_pointer>(x)) {}

        c_iterator(iterator const& x) : node_(x.node_) {}

        value_type const& operator*() const {
            return node_->value();
        }

        value_type const* operator->() const {
            return &node_->value();
        }

        c_iterator& operator++() {
            node_ = static_cast<node_pointer>(node_->next_);
            return *this;
        }

        c_iterator operator++(int) {
            c_iterator tmp(node_);
            node_ = static_cast<node_pointer>(node_->next_);
            return tmp;
        }

        friend bool operator==(c_iterator const& x, c_iterator const& y) {
            return x.node_ == y.node_;
        }

        friend bool operator!=(c_iterator const& x, c_iterator const& y) {
            return x.node_ != y.node_;
        }
    };
}}}

namespace boost { namespace unordered { namespace detail {





    template <typename NodeAlloc>
    struct node_constructor
    {
    private:

        typedef NodeAlloc node_allocator;
        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
            node_allocator_traits;
        typedef typename node_allocator_traits::value_type node;
        typedef typename node_allocator_traits::pointer node_pointer;
        typedef typename node::value_type value_type;

    protected:

        node_allocator& alloc_;
        node_pointer node_;
        bool node_constructed_;
        bool value_constructed_;

    public:

        node_constructor(node_allocator& n) :
            alloc_(n),
            node_(),
            node_constructed_(false),
            value_constructed_(false)
        {
        }

        ~node_constructor();

        void construct();

        template <typename Args>
        void construct_with_value(Args const& args)
        {
            construct();
            boost::unordered::detail::construct_value_impl(
                alloc_, node_->value_ptr(), args);
            value_constructed_ = true;
        }

        template <typename A0>
        void construct_with_value2(const A0 & a0)
        {
            construct();
            boost::unordered::detail::construct_value_impl(
                alloc_, node_->value_ptr(),
                create_emplace_args(boost::forward<A0>(a0)));
            value_constructed_ = true;
        }

        value_type const& value() const {
            ((node_ && node_constructed_ && value_constructed_) ? static_cast<void> (0) : __assert_fail ("node_ && node_constructed_ && value_constructed_", "/usr/include/boost/unordered/detail/buckets.hpp", 362, __PRETTY_FUNCTION__));
            return node_->value();
        }


        node_pointer release()
        {
            ((node_ && node_constructed_) ? static_cast<void> (0) : __assert_fail ("node_ && node_constructed_", "/usr/include/boost/unordered/detail/buckets.hpp", 369, __PRETTY_FUNCTION__));
            node_pointer p = node_;
            node_ = node_pointer();
            return p;
        }

    private:
        node_constructor(node_constructor const&);
        node_constructor& operator=(node_constructor const&);
    };

    template <typename Alloc>
    node_constructor<Alloc>::~node_constructor()
    {
        if (node_) {
            if (value_constructed_) {
                boost::unordered::detail::destroy_value_impl(alloc_,
                    node_->value_ptr());
            }

            if (node_constructed_) {
                node_allocator_traits::destroy(alloc_,
                    boost::addressof(*node_));
            }

            node_allocator_traits::deallocate(alloc_, node_, 1);
        }
    }

    template <typename Alloc>
    void node_constructor<Alloc>::construct()
    {
        if(!node_) {
            node_constructed_ = false;
            value_constructed_ = false;

            node_ = node_allocator_traits::allocate(alloc_, 1);

            node_allocator_traits::construct(alloc_,
                boost::addressof(*node_), node());
            node_->init(node_);
            node_constructed_ = true;
        }
        else {
            ((node_constructed_) ? static_cast<void> (0) : __assert_fail ("node_constructed_", "/usr/include/boost/unordered/detail/buckets.hpp", 413, __PRETTY_FUNCTION__));

            if (value_constructed_)
            {
                boost::unordered::detail::destroy_value_impl(alloc_,
                    node_->value_ptr());
                value_constructed_ = false;
            }
        }
    }







    template <typename NodeAlloc>
    struct node_holder : private node_constructor<NodeAlloc>
    {
    private:
        typedef node_constructor<NodeAlloc> base;

        typedef NodeAlloc node_allocator;
        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
            node_allocator_traits;
        typedef typename node_allocator_traits::value_type node;
        typedef typename node_allocator_traits::pointer node_pointer;
        typedef typename node::value_type value_type;
        typedef typename node::link_pointer link_pointer;
        typedef boost::unordered::iterator_detail::iterator<node> iterator;

        node_pointer nodes_;

    public:

        template <typename Table>
        explicit node_holder(Table& b) :
            base(b.node_alloc()),
            nodes_()
        {
            if (b.size_) {
                typename Table::link_pointer prev = b.get_previous_start();
                nodes_ = static_cast<node_pointer>(prev->next_);
                prev->next_ = link_pointer();
                b.size_ = 0;
            }
        }

        ~node_holder();

        void node_for_assignment()
        {
            if (!this->node_ && nodes_) {
                this->node_ = nodes_;
                nodes_ = static_cast<node_pointer>(nodes_->next_);
                this->node_->init(this->node_);
                this->node_->next_ = link_pointer();

                this->node_constructed_ = true;
                this->value_constructed_ = true;
            }
        }

        template <typename T>
        inline void assign_impl(T const& v) {
            if (this->node_ && this->value_constructed_) {
                this->node_->value() = v;
            }
            else {
                this->construct_with_value2(v);
            }
        }

        template <typename T1, typename T2>
        inline void assign_impl(std::pair<T1 const, T2> const& v) {
            this->construct_with_value2(v);
        }

        template <typename T>
        inline void move_assign_impl(T& v) {
            if (this->node_ && this->value_constructed_) {
                this->node_->value() = boost::move(v);
            }
            else {
                this->construct_with_value2(boost::move(v));
            }
        }

        template <typename T1, typename T2>
        inline void move_assign_impl(std::pair<T1 const, T2>& v) {
            this->construct_with_value2(boost::move(v));
        }

        node_pointer copy_of(value_type const& v)
        {
            node_for_assignment();
            assign_impl(v);
            return base::release();
        }

        node_pointer move_copy_of(value_type& v)
        {
            node_for_assignment();
            move_assign_impl(v);
            return base::release();
        }

        iterator begin() const
        {
            return iterator(nodes_);
        }
    };

    template <typename Alloc>
    node_holder<Alloc>::~node_holder()
    {
        while (nodes_) {
            node_pointer p = nodes_;
            nodes_ = static_cast<node_pointer>(p->next_);

            boost::unordered::detail::destroy_value_impl(this->alloc_,
                p->value_ptr());
            node_allocator_traits::destroy(this->alloc_, boost::addressof(*p));
            node_allocator_traits::deallocate(this->alloc_, p, 1);
        }
    }





    template <typename NodePointer>
    struct bucket
    {
        typedef NodePointer link_pointer;
        link_pointer next_;

        bucket() : next_() {}

        link_pointer first_from_start()
        {
            return next_;
        }

        enum { extra_node = true };
    };

    struct ptr_bucket
    {
        typedef ptr_bucket* link_pointer;
        link_pointer next_;

        ptr_bucket() : next_(0) {}

        link_pointer first_from_start()
        {
            return this;
        }

        enum { extra_node = false };
    };





    template <typename SizeT>
    struct prime_policy
    {
        template <typename Hash, typename T>
        static inline SizeT apply_hash(Hash const& hf, T const& x) {
            return hf(x);
        }

        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash) {
            return hash % bucket_count;
        }

        static inline SizeT new_bucket_count(SizeT min) {
            return boost::unordered::detail::next_prime(min);
        }

        static inline SizeT prev_bucket_count(SizeT max) {
            return boost::unordered::detail::prev_prime(max);
        }
    };

    template <typename SizeT>
    struct mix64_policy
    {
        template <typename Hash, typename T>
        static inline SizeT apply_hash(Hash const& hf, T const& x) {
            SizeT key = hf(x);
            key = (~key) + (key << 21);
            key = key ^ (key >> 24);
            key = (key + (key << 3)) + (key << 8);
            key = key ^ (key >> 14);
            key = (key + (key << 2)) + (key << 4);
            key = key ^ (key >> 28);
            key = key + (key << 31);
            return key;
        }

        static inline SizeT to_bucket(SizeT bucket_count, SizeT hash) {
            return hash & (bucket_count - 1);
        }

        static inline SizeT new_bucket_count(SizeT min) {
            if (min <= 4) return 4;
            --min;
            min |= min >> 1;
            min |= min >> 2;
            min |= min >> 4;
            min |= min >> 8;
            min |= min >> 16;
            min |= min >> 32;
            return min + 1;
        }

        static inline SizeT prev_bucket_count(SizeT max) {
            max |= max >> 1;
            max |= max >> 2;
            max |= max >> 4;
            max |= max >> 8;
            max |= max >> 16;
            max |= max >> 32;
            return (max >> 1) + 1;
        }
    };

    template <int digits, int radix>
    struct pick_policy_impl {
        typedef prime_policy<std::size_t> type;
    };

    template <>
    struct pick_policy_impl<64, 2> {
        typedef mix64_policy<std::size_t> type;
    };

    struct pick_policy :
        pick_policy_impl<
            std::numeric_limits<std::size_t>::digits,
            std::numeric_limits<std::size_t>::radix> {};
# 673 "/usr/include/boost/unordered/detail/buckets.hpp" 3 4
    template <class H, class P> class set_hash_functions;

    template <class H, class P>
    class functions
    {
        friend class boost::unordered::detail::set_hash_functions<H, P>;
        functions& operator=(functions const&);

        typedef compressed<H, P> function_pair;

        typedef typename boost::aligned_storage<
            sizeof(function_pair),
            boost::alignment_of<function_pair>::value>::type aligned_function;

        bool current_;
        aligned_function funcs_[2];

        function_pair const& current() const {
            return *static_cast<function_pair const*>(
                static_cast<void const*>(&funcs_[current_]));
        }

        void construct(bool which, H const& hf, P const& eq)
        {
            new((void*) &funcs_[which]) function_pair(hf, eq);
        }

        void construct(bool which, function_pair const& f)
        {
            new((void*) &funcs_[which]) function_pair(f);
        }

        void destroy(bool which)
        {
            boost::unordered::detail::destroy((function_pair*)(&funcs_[which]));
        }

    public:

        functions(H const& hf, P const& eq)
            : current_(false)
        {
            construct(current_, hf, eq);
        }

        functions(functions const& bf)
            : current_(false)
        {
            construct(current_, bf.current());
        }

        ~functions() {
            this->destroy(current_);
        }

        H const& hash_function() const {
            return current().first();
        }

        P const& key_eq() const {
            return current().second();
        }
    };

    template <class H, class P>
    class set_hash_functions
    {
        set_hash_functions(set_hash_functions const&);
        set_hash_functions& operator=(set_hash_functions const&);

        functions<H,P>& functions_;
        bool tmp_functions_;

    public:

        set_hash_functions(functions<H,P>& f, H const& h, P const& p)
          : functions_(f),
            tmp_functions_(!f.current_)
        {
            f.construct(tmp_functions_, h, p);
        }

        set_hash_functions(functions<H,P>& f, functions<H,P> const& other)
          : functions_(f),
            tmp_functions_(!f.current_)
        {
            f.construct(tmp_functions_, other.current());
        }

        ~set_hash_functions()
        {
            functions_.destroy(tmp_functions_);
        }

        void commit()
        {
            functions_.current_ = tmp_functions_;
            tmp_functions_ = !tmp_functions_;
        }
    };
# 781 "/usr/include/boost/unordered/detail/buckets.hpp" 3 4
    struct please_ignore_this_overload {
        typedef please_ignore_this_overload type;
    };

    template <typename T>
    struct rv_ref_impl {
        typedef ::boost::rv< T >& type;
    };

    template <typename T>
    struct rv_ref :
        boost::detail::if_true<
            boost::is_class<T>::value
        >::template then <
            boost::unordered::detail::rv_ref_impl<T>,
            please_ignore_this_overload
        >::type
    {};




}}}
# 11 "/usr/include/boost/unordered/detail/table.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/cmath" 1 3 4
# 39 "/usr/include/c++/4.8/cmath" 3 4
       
# 40 "/usr/include/c++/4.8/cmath" 3
# 15 "/usr/include/boost/unordered/detail/table.hpp" 2 3 4
# 33 "/usr/include/boost/unordered/detail/table.hpp" 3 4
namespace boost { namespace unordered { namespace detail {




    inline std::size_t double_to_size(double f)
    {
        return f >= static_cast<double>(
            (std::numeric_limits<std::size_t>::max)()) ?
            (std::numeric_limits<std::size_t>::max)() :
            static_cast<std::size_t>(f);
    }



    template <typename ValueType>
    struct value_base
    {
        typedef ValueType value_type;

        typename boost::aligned_storage<
            sizeof(value_type),
            boost::alignment_of<value_type>::value>::type data_;

        void* address() {
            return this;
        }

        value_type& value() {
            return *(ValueType*) this;
        }

        value_type* value_ptr() {
            return (ValueType*) this;
        }

    private:

        value_base& operator=(value_base const&);
    };

    template <typename NodeAlloc>
    struct copy_nodes
    {
        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
            node_allocator_traits;

        node_constructor<NodeAlloc> constructor;

        explicit copy_nodes(NodeAlloc& a) : constructor(a) {}

        typename node_allocator_traits::pointer create(
                typename node_allocator_traits::value_type::value_type const& v)
        {
            constructor.construct_with_value2(v);
            return constructor.release();
        }
    };

    template <typename NodeAlloc>
    struct move_nodes
    {
        typedef boost::unordered::detail::allocator_traits<NodeAlloc>
            node_allocator_traits;

        node_constructor<NodeAlloc> constructor;

        explicit move_nodes(NodeAlloc& a) : constructor(a) {}

        typename node_allocator_traits::pointer create(
                typename node_allocator_traits::value_type::value_type& v)
        {
            constructor.construct_with_value2(boost::move(v));
            return constructor.release();
        }
    };

    template <typename Buckets>
    struct assign_nodes
    {
        node_holder<typename Buckets::node_allocator> holder;

        explicit assign_nodes(Buckets& b) : holder(b) {}

        typename Buckets::node_pointer create(
                typename Buckets::value_type const& v)
        {
            return holder.copy_of(v);
        }
    };

    template <typename Buckets>
    struct move_assign_nodes
    {
        node_holder<typename Buckets::node_allocator> holder;

        explicit move_assign_nodes(Buckets& b) : holder(b) {}

        typename Buckets::node_pointer create(
                typename Buckets::value_type& v)
        {
            return holder.move_copy_of(v);
        }
    };

    template <typename Types>
    struct table :
        boost::unordered::detail::functions<
            typename Types::hasher,
            typename Types::key_equal>
    {
    private:
        table(table const&);
        table& operator=(table const&);
    public:
        typedef typename Types::node node;
        typedef typename Types::bucket bucket;
        typedef typename Types::hasher hasher;
        typedef typename Types::key_equal key_equal;
        typedef typename Types::key_type key_type;
        typedef typename Types::extractor extractor;
        typedef typename Types::value_type value_type;
        typedef typename Types::table table_impl;
        typedef typename Types::link_pointer link_pointer;
        typedef typename Types::policy policy;

        typedef boost::unordered::detail::functions<
            typename Types::hasher,
            typename Types::key_equal> functions;

        typedef typename Types::allocator allocator;
        typedef typename boost::unordered::detail::
            rebind_wrap<allocator, node>::type node_allocator;
        typedef typename boost::unordered::detail::
            rebind_wrap<allocator, bucket>::type bucket_allocator;
        typedef boost::unordered::detail::allocator_traits<node_allocator>
            node_allocator_traits;
        typedef boost::unordered::detail::allocator_traits<bucket_allocator>
            bucket_allocator_traits;
        typedef typename node_allocator_traits::pointer
            node_pointer;
        typedef typename node_allocator_traits::const_pointer
            const_node_pointer;
        typedef typename bucket_allocator_traits::pointer
            bucket_pointer;
        typedef boost::unordered::detail::node_constructor<node_allocator>
            node_constructor;

        typedef boost::unordered::iterator_detail::
            iterator<node> iterator;
        typedef boost::unordered::iterator_detail::
            c_iterator<node, const_node_pointer> c_iterator;
        typedef boost::unordered::iterator_detail::
            l_iterator<node, policy> l_iterator;
        typedef boost::unordered::iterator_detail::
            cl_iterator<node, const_node_pointer, policy> cl_iterator;




        boost::unordered::detail::compressed<bucket_allocator, node_allocator>
            allocators_;
        std::size_t bucket_count_;
        std::size_t size_;
        float mlf_;
        std::size_t max_load_;
        bucket_pointer buckets_;




        bucket_allocator const& bucket_alloc() const
        {
            return allocators_.first();
        }

        node_allocator const& node_alloc() const
        {
            return allocators_.second();
        }

        bucket_allocator& bucket_alloc()
        {
            return allocators_.first();
        }

        node_allocator& node_alloc()
        {
            return allocators_.second();
        }

        std::size_t max_bucket_count() const
        {

            return policy::prev_bucket_count(
                bucket_allocator_traits::max_size(bucket_alloc()) - 1);
        }

        bucket_pointer get_bucket(std::size_t bucket_index) const
        {
            ((buckets_) ? static_cast<void> (0) : __assert_fail ("buckets_", "/usr/include/boost/unordered/detail/table.hpp", 233, __PRETTY_FUNCTION__));
            return buckets_ + static_cast<std::ptrdiff_t>(bucket_index);
        }

        link_pointer get_previous_start() const
        {
            return get_bucket(bucket_count_)->first_from_start();
        }

        link_pointer get_previous_start(std::size_t bucket_index) const
        {
            return get_bucket(bucket_index)->next_;
        }

        iterator begin() const
        {
            return size_ ? iterator(get_previous_start()->next_) : iterator();
        }

        iterator begin(std::size_t bucket_index) const
        {
            if (!size_) return iterator();
            link_pointer prev = get_previous_start(bucket_index);
            return prev ? iterator(prev->next_) : iterator();
        }

        std::size_t hash_to_bucket(std::size_t hash) const
        {
            return policy::to_bucket(bucket_count_, hash);
        }

        float load_factor() const
        {
            ((bucket_count_ != 0) ? static_cast<void> (0) : __assert_fail ("bucket_count_ != 0", "/usr/include/boost/unordered/detail/table.hpp", 266, __PRETTY_FUNCTION__));
            return static_cast<float>(size_)
                / static_cast<float>(bucket_count_);
        }

        std::size_t bucket_size(std::size_t index) const
        {
            iterator it = begin(index);
            if (!it.node_) return 0;

            std::size_t count = 0;
            while(it.node_ && hash_to_bucket(it.node_->hash_) == index)
            {
                ++count;
                ++it;
            }

            return count;
        }




        std::size_t max_size() const
        {
            using namespace std;


            return boost::unordered::detail::double_to_size(ceil(
                    static_cast<double>(mlf_) *
                    static_cast<double>(max_bucket_count())
                )) - 1;
        }

        void recalculate_max_load()
        {
            using namespace std;



            max_load_ = buckets_ ? boost::unordered::detail::double_to_size(ceil(
                    static_cast<double>(mlf_) *
                    static_cast<double>(bucket_count_)
                )) : 0;

        }

        void max_load_factor(float z)
        {
            ((z > 0) ? static_cast<void> (0) : __assert_fail ("z > 0", "/usr/include/boost/unordered/detail/table.hpp", 315, __PRETTY_FUNCTION__));
            mlf_ = (std::max)(z, minimum_max_load_factor);
            recalculate_max_load();
        }

        std::size_t min_buckets_for_size(std::size_t size) const
        {
            ((mlf_ >= minimum_max_load_factor) ? static_cast<void> (0) : __assert_fail ("mlf_ >= minimum_max_load_factor", "/usr/include/boost/unordered/detail/table.hpp", 322, __PRETTY_FUNCTION__));

            using namespace std;
# 333 "/usr/include/boost/unordered/detail/table.hpp" 3 4
            return policy::new_bucket_count(
                boost::unordered::detail::double_to_size(floor(
                    static_cast<double>(size) /
                    static_cast<double>(mlf_))) + 1);
        }




        table(std::size_t num_buckets,
                hasher const& hf,
                key_equal const& eq,
                node_allocator const& a) :
            functions(hf, eq),
            allocators_(a,a),
            bucket_count_(policy::new_bucket_count(num_buckets)),
            size_(0),
            mlf_(1.0f),
            max_load_(0),
            buckets_()
        {}

        table(table const& x, node_allocator const& a) :
            functions(x),
            allocators_(a,a),
            bucket_count_(x.min_buckets_for_size(x.size_)),
            size_(0),
            mlf_(x.mlf_),
            max_load_(0),
            buckets_()
        {}

        table(table& x, boost::unordered::detail::move_tag m) :
            functions(x),
            allocators_(x.allocators_, m),
            bucket_count_(x.bucket_count_),
            size_(x.size_),
            mlf_(x.mlf_),
            max_load_(x.max_load_),
            buckets_(x.buckets_)
        {
            x.buckets_ = bucket_pointer();
            x.size_ = 0;
            x.max_load_ = 0;
        }

        table(table& x, node_allocator const& a,
                boost::unordered::detail::move_tag) :
            functions(x),
            allocators_(a, a),
            bucket_count_(x.bucket_count_),
            size_(0),
            mlf_(x.mlf_),
            max_load_(x.max_load_),
            buckets_()
        {}




        void init(table const& x)
        {
            if (x.size_) {
                create_buckets(bucket_count_);
                copy_nodes<node_allocator> copy(node_alloc());
                table_impl::fill_buckets(x.begin(), *this, copy);
            }
        }

        void move_init(table& x)
        {
            if(node_alloc() == x.node_alloc()) {
                move_buckets_from(x);
            }
            else if(x.size_) {

                create_buckets(bucket_count_);

                move_nodes<node_allocator> move(node_alloc());
                node_holder<node_allocator> nodes(x);
                table_impl::fill_buckets(nodes.begin(), *this, move);
            }
        }




        void create_buckets(std::size_t new_count)
        {
            boost::unordered::detail::array_constructor<bucket_allocator>
                constructor(bucket_alloc());


            constructor.construct(bucket(), new_count + 1);

            if (buckets_)
            {


                (constructor.get() +
                    static_cast<std::ptrdiff_t>(new_count))->next_ =
                        (buckets_ + static_cast<std::ptrdiff_t>(
                            bucket_count_))->next_;
                destroy_buckets();
            }
            else if (bucket::extra_node)
            {
                node_constructor a(node_alloc());
                a.construct();

                (constructor.get() +
                    static_cast<std::ptrdiff_t>(new_count))->next_ =
                        a.release();
            }

            bucket_count_ = new_count;
            buckets_ = constructor.release();
            recalculate_max_load();
        }




        void swap_allocators(table& other, false_type)
        {



            ((node_alloc() == other.node_alloc()) ? static_cast<void> (0) : __assert_fail ("node_alloc() == other.node_alloc()", "/usr/include/boost/unordered/detail/table.hpp", 461, __PRETTY_FUNCTION__));
        }

        void swap_allocators(table& other, true_type)
        {
            allocators_.swap(other.allocators_);
        }


        void swap(table& x)
        {
            boost::unordered::detail::set_hash_functions<hasher, key_equal>
                op1(*this, x);
            boost::unordered::detail::set_hash_functions<hasher, key_equal>
                op2(x, *this);



            swap_allocators(x,
                boost::unordered::detail::integral_constant<bool,
                    allocator_traits<node_allocator>::
                    propagate_on_container_swap::value>());

            boost::swap(buckets_, x.buckets_);
            boost::swap(bucket_count_, x.bucket_count_);
            boost::swap(size_, x.size_);
            std::swap(mlf_, x.mlf_);
            std::swap(max_load_, x.max_load_);
            op1.commit();
            op2.commit();
        }

        void move_buckets_from(table& other)
        {
            ((node_alloc() == other.node_alloc()) ? static_cast<void> (0) : __assert_fail ("node_alloc() == other.node_alloc()", "/usr/include/boost/unordered/detail/table.hpp", 495, __PRETTY_FUNCTION__));
            ((!buckets_) ? static_cast<void> (0) : __assert_fail ("!buckets_", "/usr/include/boost/unordered/detail/table.hpp", 496, __PRETTY_FUNCTION__));
            buckets_ = other.buckets_;
            bucket_count_ = other.bucket_count_;
            size_ = other.size_;
            other.buckets_ = bucket_pointer();
            other.size_ = 0;
            other.max_load_ = 0;
        }




        ~table()
        {
            delete_buckets();
        }

        void delete_node(link_pointer prev)
        {
            node_pointer n = static_cast<node_pointer>(prev->next_);
            prev->next_ = n->next_;

            boost::unordered::detail::destroy_value_impl(node_alloc(),
                n->value_ptr());
            node_allocator_traits::destroy(node_alloc(),
                    boost::addressof(*n));
            node_allocator_traits::deallocate(node_alloc(), n, 1);
            --size_;
        }

        std::size_t delete_nodes(link_pointer prev, link_pointer end)
        {
            ((prev->next_ != end) ? static_cast<void> (0) : __assert_fail ("prev->next_ != end", "/usr/include/boost/unordered/detail/table.hpp", 528, __PRETTY_FUNCTION__));

            std::size_t count = 0;

            do {
                delete_node(prev);
                ++count;
            } while (prev->next_ != end);

            return count;
        }

        void delete_buckets()
        {
            if(buckets_) {
                if (size_) delete_nodes(get_previous_start(), link_pointer());

                if (bucket::extra_node) {
                    node_pointer n = static_cast<node_pointer>(
                            get_bucket(bucket_count_)->next_);
                    node_allocator_traits::destroy(node_alloc(),
                            boost::addressof(*n));
                    node_allocator_traits::deallocate(node_alloc(), n, 1);
                }

                destroy_buckets();
                buckets_ = bucket_pointer();
                max_load_ = 0;
            }

            ((!size_) ? static_cast<void> (0) : __assert_fail ("!size_", "/usr/include/boost/unordered/detail/table.hpp", 558, __PRETTY_FUNCTION__));
        }

        void clear()
        {
            if (!size_) return;

            delete_nodes(get_previous_start(), link_pointer());
            clear_buckets();

            ((!size_) ? static_cast<void> (0) : __assert_fail ("!size_", "/usr/include/boost/unordered/detail/table.hpp", 568, __PRETTY_FUNCTION__));
        }

        void clear_buckets()
        {
            bucket_pointer end = get_bucket(bucket_count_);
            for(bucket_pointer it = buckets_; it != end; ++it)
            {
                it->next_ = node_pointer();
            }
        }

        void destroy_buckets()
        {
            bucket_pointer end = get_bucket(bucket_count_ + 1);
            for(bucket_pointer it = buckets_; it != end; ++it)
            {
                bucket_allocator_traits::destroy(bucket_alloc(),
                    boost::addressof(*it));
            }

            bucket_allocator_traits::deallocate(bucket_alloc(),
                buckets_, bucket_count_ + 1);
        }





        std::size_t fix_bucket(std::size_t bucket_index, link_pointer prev)
        {
            link_pointer end = prev->next_;
            std::size_t bucket_index2 = bucket_index;

            if (end)
            {
                bucket_index2 = hash_to_bucket(
                    static_cast<node_pointer>(end)->hash_);



                if (bucket_index == bucket_index2) return bucket_index2;


                get_bucket(bucket_index2)->next_ = prev;
            }


            bucket_pointer this_bucket = get_bucket(bucket_index);
            if (this_bucket->next_ == prev)
                this_bucket->next_ = link_pointer();

            return bucket_index2;
        }




        void assign(table const& x)
        {
            if (this != boost::addressof(x))
            {
                assign(x,
                    boost::unordered::detail::integral_constant<bool,
                        allocator_traits<node_allocator>::
                        propagate_on_container_copy_assignment::value>());
            }
        }

        void assign(table const& x, false_type)
        {

            boost::unordered::detail::set_hash_functions<hasher, key_equal>
                new_func_this(*this, x);
            new_func_this.commit();
            mlf_ = x.mlf_;
            recalculate_max_load();

            if (!size_ && !x.size_) return;

            if (x.size_ >= max_load_) {
                create_buckets(min_buckets_for_size(x.size_));
            }
            else {
                clear_buckets();
            }




            assign_nodes<table> assign(*this);
            table_impl::fill_buckets(x.begin(), *this, assign);
        }

        void assign(table const& x, true_type)
        {
            if (node_alloc() == x.node_alloc()) {
                allocators_.assign(x.allocators_);
                assign(x, false_type());
            }
            else {
                boost::unordered::detail::set_hash_functions<hasher, key_equal>
                    new_func_this(*this, x);



                delete_buckets();
                allocators_.assign(x.allocators_);


                new_func_this.commit();
                mlf_ = x.mlf_;
                bucket_count_ = min_buckets_for_size(x.size_);
                max_load_ = 0;


                if (x.size_) {
                    create_buckets(bucket_count_);
                    copy_nodes<node_allocator> copy(node_alloc());
                    table_impl::fill_buckets(x.begin(), *this, copy);
                }
            }
        }

        void move_assign(table& x)
        {
            if (this != boost::addressof(x))
            {
                move_assign(x,
                    boost::unordered::detail::integral_constant<bool,
                        allocator_traits<node_allocator>::
                        propagate_on_container_move_assignment::value>());
            }
        }

        void move_assign(table& x, true_type)
        {
            delete_buckets();
            allocators_.move_assign(x.allocators_);
            move_assign_no_alloc(x);
        }

        void move_assign(table& x, false_type)
        {
            if (node_alloc() == x.node_alloc()) {
                delete_buckets();
                move_assign_no_alloc(x);
            }
            else {
                boost::unordered::detail::set_hash_functions<hasher, key_equal>
                    new_func_this(*this, x);
                new_func_this.commit();
                mlf_ = x.mlf_;
                recalculate_max_load();

                if (!size_ && !x.size_) return;

                if (x.size_ >= max_load_) {
                    create_buckets(min_buckets_for_size(x.size_));
                }
                else {
                    clear_buckets();
                }




                move_assign_nodes<table> assign(*this);
                node_holder<node_allocator> nodes(x);
                table_impl::fill_buckets(nodes.begin(), *this, assign);
            }
        }

        void move_assign_no_alloc(table& x)
        {
            boost::unordered::detail::set_hash_functions<hasher, key_equal>
                new_func_this(*this, x);

            mlf_ = x.mlf_;
            max_load_ = x.max_load_;
            move_buckets_from(x);
            new_func_this.commit();
        }



        key_type const& get_key(value_type const& x) const
        {
            return extractor::extract(x);
        }

        std::size_t hash(key_type const& k) const
        {
            return policy::apply_hash(this->hash_function(), k);
        }



        template <typename Key, typename Hash, typename Pred>
        iterator generic_find_node(
                Key const& k,
                Hash const& hf,
                Pred const& eq) const
        {
            return static_cast<table_impl const*>(this)->
                find_node_impl(policy::apply_hash(hf, k), k, eq);
        }

        iterator find_node(
                std::size_t key_hash,
                key_type const& k) const
        {
            return static_cast<table_impl const*>(this)->
                find_node_impl(key_hash, k, this->key_eq());
        }

        iterator find_node(key_type const& k) const
        {
            return static_cast<table_impl const*>(this)->
                find_node_impl(hash(k), k, this->key_eq());
        }

        iterator find_matching_node(iterator n) const
        {






            return find_node(get_key(*n));
        }



        void reserve_for_insert(std::size_t);
        void rehash(std::size_t);
        void reserve(std::size_t);
    };





    template <typename Types>
    inline void table<Types>::reserve_for_insert(std::size_t size)
    {
        if (!buckets_) {
            create_buckets((std::max)(bucket_count_,
                min_buckets_for_size(size)));
        }


        else if(size > max_load_) {
            std::size_t num_buckets
                = min_buckets_for_size((std::max)(size,
                    size_ + (size_ >> 1)));

            if (num_buckets != bucket_count_)
                static_cast<table_impl*>(this)->rehash_impl(num_buckets);
        }
    }




    template <typename Types>
    inline void table<Types>::rehash(std::size_t min_buckets)
    {
        using namespace std;

        if(!size_) {
            delete_buckets();
            bucket_count_ = policy::new_bucket_count(min_buckets);
        }
        else {
            min_buckets = policy::new_bucket_count((std::max)(min_buckets,
                boost::unordered::detail::double_to_size(floor(
                    static_cast<double>(size_) /
                    static_cast<double>(mlf_))) + 1));

            if(min_buckets != bucket_count_)
                static_cast<table_impl*>(this)->rehash_impl(min_buckets);
        }
    }

    template <typename Types>
    inline void table<Types>::reserve(std::size_t num_elements)
    {
        rehash(static_cast<std::size_t>(
            std::ceil(static_cast<double>(num_elements) / mlf_)));
    }
}}}
# 15 "/usr/include/boost/unordered/detail/equivalent.hpp" 2 3 4
# 1 "/usr/include/boost/unordered/detail/extract_key.hpp" 1 3 4
# 11 "/usr/include/boost/unordered/detail/extract_key.hpp" 3 4
namespace boost {
namespace unordered {
namespace detail {
# 25 "/usr/include/boost/unordered/detail/extract_key.hpp" 3 4
    struct no_key {
        no_key() {}
        template <class T> no_key(T const&) {}
    };

    template <typename Key, typename T>
    struct is_key {
        template <typename T2>
        static choice1::type test(T2 const&);
        static choice2::type test(Key const&);

        enum { value = sizeof(test(boost::unordered::detail::make<T>())) ==
            sizeof(choice2::type) };

        typedef typename boost::detail::if_true<value>::
            template then<Key const&, no_key>::type type;
    };

    template <class ValueType>
    struct set_extractor
    {
        typedef ValueType value_type;
        typedef ValueType key_type;

        static key_type const& extract(key_type const& v)
        {
            return v;
        }

        static no_key extract()
        {
            return no_key();
        }
# 66 "/usr/include/boost/unordered/detail/extract_key.hpp" 3 4
        template <class Arg>
        static no_key extract(Arg const&)
        {
            return no_key();
        }

        template <class Arg1, class Arg2>
        static no_key extract(Arg1 const&, Arg2 const&)
        {
            return no_key();
        }

    };

    template <class Key, class ValueType>
    struct map_extractor
    {
        typedef ValueType value_type;
        typedef typename boost::remove_const<Key>::type key_type;

        static key_type const& extract(value_type const& v)
        {
            return v.first;
        }

        template <class Second>
        static key_type const& extract(std::pair<key_type, Second> const& v)
        {
            return v.first;
        }

        template <class Second>
        static key_type const& extract(
            std::pair<key_type const, Second> const& v)
        {
            return v.first;
        }

        template <class Arg1>
        static key_type const& extract(key_type const& k, Arg1 const&)
        {
            return k;
        }
# 118 "/usr/include/boost/unordered/detail/extract_key.hpp" 3 4
        static no_key extract()
        {
            return no_key();
        }

        template <class Arg>
        static no_key extract(Arg const&)
        {
            return no_key();
        }

        template <class Arg, class Arg1>
        static no_key extract(Arg const&, Arg1 const&)
        {
            return no_key();
        }
# 175 "/usr/include/boost/unordered/detail/extract_key.hpp" 3 4
static no_key extract(boost::unordered::piecewise_construct_t, boost:: tuple<> const&) { return no_key(); } template <typename T> static typename is_key<key_type, T>::type extract(boost::unordered::piecewise_construct_t, boost:: tuple<T> const& k) { return typename is_key<key_type, T>::type( boost:: get<0>(k)); }




    };
}}}
# 16 "/usr/include/boost/unordered/detail/equivalent.hpp" 2 3 4

namespace boost { namespace unordered { namespace detail {

    template <typename A, typename T> struct grouped_node;
    template <typename T> struct grouped_ptr_node;
    template <typename Types> struct grouped_table_impl;

    template <typename A, typename T>
    struct grouped_node :
        boost::unordered::detail::value_base<T>
    {
        typedef typename ::boost::unordered::detail::rebind_wrap<
            A, grouped_node<A, T> >::type allocator;
        typedef typename ::boost::unordered::detail::
            allocator_traits<allocator>::pointer node_pointer;
        typedef node_pointer link_pointer;

        link_pointer next_;
        node_pointer group_prev_;
        std::size_t hash_;

        grouped_node() :
            next_(),
            group_prev_(),
            hash_(0)
        {}

        void init(node_pointer self)
        {
            group_prev_ = self;
        }

    private:
        grouped_node& operator=(grouped_node const&);
    };

    template <typename T>
    struct grouped_ptr_node :
        boost::unordered::detail::value_base<T>,
        boost::unordered::detail::ptr_bucket
    {
        typedef boost::unordered::detail::ptr_bucket bucket_base;
        typedef grouped_ptr_node<T>* node_pointer;
        typedef ptr_bucket* link_pointer;

        node_pointer group_prev_;
        std::size_t hash_;

        grouped_ptr_node() :
            bucket_base(),
            group_prev_(0),
            hash_(0)
        {}

        void init(node_pointer self)
        {
            group_prev_ = self;
        }

    private:
        grouped_ptr_node& operator=(grouped_ptr_node const&);
    };




    template <typename A, typename T, typename NodePtr, typename BucketPtr>
    struct pick_grouped_node2
    {
        typedef boost::unordered::detail::grouped_node<A, T> node;

        typedef typename boost::unordered::detail::allocator_traits<
            typename boost::unordered::detail::rebind_wrap<A, node>::type
        >::pointer node_pointer;

        typedef boost::unordered::detail::bucket<node_pointer> bucket;
        typedef node_pointer link_pointer;
    };

    template <typename A, typename T>
    struct pick_grouped_node2<A, T,
        boost::unordered::detail::grouped_ptr_node<T>*,
        boost::unordered::detail::ptr_bucket*>
    {
        typedef boost::unordered::detail::grouped_ptr_node<T> node;
        typedef boost::unordered::detail::ptr_bucket bucket;
        typedef bucket* link_pointer;
    };

    template <typename A, typename T>
    struct pick_grouped_node
    {
        typedef boost::unordered::detail::allocator_traits<
            typename boost::unordered::detail::rebind_wrap<A,
                boost::unordered::detail::grouped_ptr_node<T> >::type
        > tentative_node_traits;

        typedef boost::unordered::detail::allocator_traits<
            typename boost::unordered::detail::rebind_wrap<A,
                boost::unordered::detail::ptr_bucket >::type
        > tentative_bucket_traits;

        typedef pick_grouped_node2<A, T,
            typename tentative_node_traits::pointer,
            typename tentative_bucket_traits::pointer> pick;

        typedef typename pick::node node;
        typedef typename pick::bucket bucket;
        typedef typename pick::link_pointer link_pointer;
    };

    template <typename A, typename T, typename H, typename P>
    struct multiset
    {
        typedef boost::unordered::detail::multiset<A, T, H, P> types;

        typedef A allocator;
        typedef T value_type;
        typedef H hasher;
        typedef P key_equal;
        typedef T key_type;

        typedef boost::unordered::detail::allocator_traits<allocator> traits;
        typedef boost::unordered::detail::pick_grouped_node<allocator,
            value_type> pick;
        typedef typename pick::node node;
        typedef typename pick::bucket bucket;
        typedef typename pick::link_pointer link_pointer;

        typedef boost::unordered::detail::grouped_table_impl<types> table;
        typedef boost::unordered::detail::set_extractor<value_type> extractor;

        typedef boost::unordered::detail::pick_policy::type policy;
    };

    template <typename A, typename K, typename M, typename H, typename P>
    struct multimap
    {
        typedef boost::unordered::detail::multimap<A, K, M, H, P> types;

        typedef A allocator;
        typedef std::pair<K const, M> value_type;
        typedef H hasher;
        typedef P key_equal;
        typedef K key_type;

        typedef boost::unordered::detail::allocator_traits<allocator> traits;
        typedef boost::unordered::detail::pick_grouped_node<allocator,
                value_type> pick;
        typedef typename pick::node node;
        typedef typename pick::bucket bucket;
        typedef typename pick::link_pointer link_pointer;

        typedef boost::unordered::detail::grouped_table_impl<types> table;
        typedef boost::unordered::detail::map_extractor<key_type, value_type>
            extractor;

        typedef boost::unordered::detail::pick_policy::type policy;
    };

    template <typename Types>
    struct grouped_table_impl : boost::unordered::detail::table<Types>
    {
        typedef boost::unordered::detail::table<Types> table;
        typedef typename table::value_type value_type;
        typedef typename table::bucket bucket;
        typedef typename table::policy policy;
        typedef typename table::node_pointer node_pointer;
        typedef typename table::node_allocator node_allocator;
        typedef typename table::node_allocator_traits node_allocator_traits;
        typedef typename table::bucket_pointer bucket_pointer;
        typedef typename table::link_pointer link_pointer;
        typedef typename table::hasher hasher;
        typedef typename table::key_equal key_equal;
        typedef typename table::key_type key_type;
        typedef typename table::node_constructor node_constructor;
        typedef typename table::extractor extractor;
        typedef typename table::iterator iterator;
        typedef typename table::c_iterator c_iterator;



        grouped_table_impl(std::size_t n,
                hasher const& hf,
                key_equal const& eq,
                node_allocator const& a)
          : table(n, hf, eq, a)
        {}

        grouped_table_impl(grouped_table_impl const& x)
          : table(x, node_allocator_traits::
                select_on_container_copy_construction(x.node_alloc()))
        {
            this->init(x);
        }

        grouped_table_impl(grouped_table_impl const& x,
                node_allocator const& a)
          : table(x, a)
        {
            this->init(x);
        }

        grouped_table_impl(grouped_table_impl& x,
                boost::unordered::detail::move_tag m)
          : table(x, m)
        {}

        grouped_table_impl(grouped_table_impl& x,
                node_allocator const& a,
                boost::unordered::detail::move_tag m)
          : table(x, a, m)
        {
            this->move_init(x);
        }



        template <class Key, class Pred>
        iterator find_node_impl(
                std::size_t key_hash,
                Key const& k,
                Pred const& eq) const
        {
            std::size_t bucket_index = this->hash_to_bucket(key_hash);
            iterator n = this->begin(bucket_index);

            for (;;)
            {
                if (!n.node_) return n;

                std::size_t node_hash = n.node_->hash_;
                if (key_hash == node_hash)
                {
                    if (eq(k, this->get_key(*n)))
                        return n;
                }
                else
                {
                    if (this->hash_to_bucket(node_hash) != bucket_index)
                        return iterator();
                }

                n = iterator(n.node_->group_prev_->next_);
            }
        }

        std::size_t count(key_type const& k) const
        {
            iterator n = this->find_node(k);
            if (!n.node_) return 0;

            std::size_t x = 0;
            node_pointer it = n.node_;
            do {
                it = it->group_prev_;
                ++x;
            } while(it != n.node_);

            return x;
        }

        std::pair<iterator, iterator>
            equal_range(key_type const& k) const
        {
            iterator n = this->find_node(k);
            return std::make_pair(
                n, n.node_ ? iterator(n.node_->group_prev_->next_) : n);
        }



        bool equals(grouped_table_impl const& other) const
        {
            if(this->size_ != other.size_) return false;

            for(iterator n1 = this->begin(); n1.node_;)
            {
                iterator n2 = other.find_matching_node(n1);
                if (!n2.node_) return false;
                iterator end1(n1.node_->group_prev_->next_);
                iterator end2(n2.node_->group_prev_->next_);
                if (!group_equals(n1, end1, n2, end2)) return false;
                n1 = end1;
            }

            return true;
        }

        static bool group_equals(iterator n1, iterator end1,
                iterator n2, iterator end2)
        {
            for(;;)
            {
                if (*n1 != *n2) break;

                ++n1;
                ++n2;

                if (n1 == end1) return n2 == end2;
                if (n2 == end2) return false;
            }

            for(iterator n1a = n1, n2a = n2;;)
            {
                ++n1a;
                ++n2a;

                if (n1a == end1)
                {
                    if (n2a == end2) break;
                    else return false;
                }

                if (n2a == end2) return false;
            }

            iterator start = n1;
            for(;n1 != end1; ++n1)
            {
                value_type const& v = *n1;
                if (find(start, n1, v)) continue;
                std::size_t matches = count_equal(n2, end2, v);
                if (!matches) return false;
                iterator next = n1;
                ++next;
                if (matches != 1 + count_equal(next, end1, v)) return false;
            }

            return true;
        }

        static bool find(iterator n, iterator end, value_type const& v)
        {
            for(;n != end; ++n)
                if (*n == v)
                    return true;
            return false;
        }

        static std::size_t count_equal(iterator n, iterator end,
            value_type const& v)
        {
            std::size_t count = 0;
            for(;n != end; ++n)
                if (*n == v) ++count;
            return count;
        }



        static inline void add_after_node(
                node_pointer n,
                node_pointer pos)
        {
            n->next_ = pos->group_prev_->next_;
            n->group_prev_ = pos->group_prev_;
            pos->group_prev_->next_ = n;
            pos->group_prev_ = n;
        }

        inline iterator add_node(
                node_constructor& a,
                std::size_t key_hash,
                iterator pos)
        {
            node_pointer n = a.release();
            n->hash_ = key_hash;
            if (pos.node_) {
                this->add_after_node(n, pos.node_);
                if (n->next_) {
                    std::size_t next_bucket = this->hash_to_bucket(
                        static_cast<node_pointer>(n->next_)->hash_);
                    if (next_bucket != this->hash_to_bucket(key_hash)) {
                        this->get_bucket(next_bucket)->next_ = n;
                    }
                }
            }
            else {
                bucket_pointer b = this->get_bucket(
                    this->hash_to_bucket(key_hash));

                if (!b->next_)
                {
                    link_pointer start_node = this->get_previous_start();

                    if (start_node->next_) {
                        this->get_bucket(this->hash_to_bucket(
                            static_cast<node_pointer>(start_node->next_)->hash_
                        ))->next_ = n;
                    }

                    b->next_ = start_node;
                    n->next_ = start_node->next_;
                    start_node->next_ = n;
                }
                else
                {
                    n->next_ = b->next_->next_;
                    b->next_->next_ = n;
                }
            }
            ++this->size_;
            return iterator(n);
        }

        iterator emplace_impl(node_constructor& a)
        {
            key_type const& k = this->get_key(a.value());
            std::size_t key_hash = this->hash(k);
            iterator position = this->find_node(key_hash, k);



            this->reserve_for_insert(this->size_ + 1);
            return this->add_node(a, key_hash, position);
        }

        void emplace_impl_no_rehash(node_constructor& a)
        {
            key_type const& k = this->get_key(a.value());
            std::size_t key_hash = this->hash(k);
            this->add_node(a, key_hash, this->find_node(key_hash, k));
        }



        iterator emplace(boost::unordered::detail::emplace_args1<
                boost::unordered::detail::please_ignore_this_overload> const&)
        {
            ((false) ? static_cast<void> (0) : __assert_fail ("false", "/usr/include/boost/unordered/detail/equivalent.hpp", 446, __PRETTY_FUNCTION__));
            return iterator();
        }
# 459 "/usr/include/boost/unordered/detail/equivalent.hpp" 3 4
        template <typename Args>
        iterator emplace(Args const& args)
        {
            node_constructor a(this->node_alloc());
            a.construct_with_value(args);

            return iterator(emplace_impl(a));
        }






        template <class I>
        typename boost::unordered::detail::enable_if_forward<I, void>::type
            insert_range(I i, I j)
        {
            if(i == j) return;

            std::size_t distance = boost::unordered::detail::distance(i, j);
            if(distance == 1) {
                node_constructor a(this->node_alloc());
                a.construct_with_value2(*i);
                emplace_impl(a);
            }
            else {

                this->reserve_for_insert(this->size_ + distance);

                node_constructor a(this->node_alloc());
                for (; i != j; ++i) {
                    a.construct_with_value2(*i);
                    emplace_impl_no_rehash(a);
                }
            }
        }

        template <class I>
        typename boost::unordered::detail::disable_if_forward<I, void>::type
            insert_range(I i, I j)
        {
            node_constructor a(this->node_alloc());
            for (; i != j; ++i) {
                a.construct_with_value2(*i);
                emplace_impl(a);
            }
        }






        std::size_t erase_key(key_type const& k)
        {
            if(!this->size_) return 0;

            std::size_t key_hash = this->hash(k);
            std::size_t bucket_index = this->hash_to_bucket(key_hash);
            link_pointer prev = this->get_previous_start(bucket_index);
            if (!prev) return 0;

            for (;;)
            {
                if (!prev->next_) return 0;
                std::size_t node_hash =
                    static_cast<node_pointer>(prev->next_)->hash_;
                if (this->hash_to_bucket(node_hash) != bucket_index)
                    return 0;
                if (node_hash == key_hash &&
                    this->key_eq()(k, this->get_key(
                        static_cast<node_pointer>(prev->next_)->value())))
                    break;
                prev = static_cast<node_pointer>(prev->next_)->group_prev_;
            }

            node_pointer first_node = static_cast<node_pointer>(prev->next_);
            link_pointer end = first_node->group_prev_->next_;

            std::size_t count = this->delete_nodes(prev, end);
            this->fix_bucket(bucket_index, prev);
            return count;
        }

        iterator erase(c_iterator r)
        {
            ((r.node_) ? static_cast<void> (0) : __assert_fail ("r.node_", "/usr/include/boost/unordered/detail/equivalent.hpp", 546, __PRETTY_FUNCTION__));
            iterator next(r.node_);
            ++next;
            erase_nodes(r.node_, next.node_);
            return next;
        }

        iterator erase_range(c_iterator r1, c_iterator r2)
        {
            if (r1 == r2) return iterator(r2.node_);
            erase_nodes(r1.node_, r2.node_);
            return iterator(r2.node_);
        }

        link_pointer erase_nodes(node_pointer begin, node_pointer end)
        {
            std::size_t bucket_index = this->hash_to_bucket(begin->hash_);




            link_pointer prev = split_groups(begin, end);




            if (!prev) {
                prev = this->get_previous_start(bucket_index);
                while (prev->next_ != begin)
                    prev = static_cast<node_pointer>(prev->next_)->group_prev_;
            }


            do {
                link_pointer group_end =
                    static_cast<node_pointer>(prev->next_)->group_prev_->next_;
                this->delete_nodes(prev, group_end);
                bucket_index = this->fix_bucket(bucket_index, prev);
            } while(prev->next_ != end);

            return prev;
        }

        static link_pointer split_groups(node_pointer begin, node_pointer end)
        {
            node_pointer prev = begin->group_prev_;
            if (prev->next_ != begin) prev = node_pointer();

            if (end) {
                node_pointer first = end;
                while (first != begin && first->group_prev_->next_ == first) {
                    first = first->group_prev_;
                }

                boost::swap(first->group_prev_, end->group_prev_);
                if (first == begin) return prev;
            }

            if (prev) {
                node_pointer first = prev;
                while (first->group_prev_->next_ == first) {
                    first = first->group_prev_;
                }
                boost::swap(first->group_prev_, begin->group_prev_);
            }

            return prev;
        }




        template <class NodeCreator>
        static void fill_buckets(iterator n, table& dst,
            NodeCreator& creator)
        {
            link_pointer prev = dst.get_previous_start();

            while (n.node_) {
                std::size_t key_hash = n.node_->hash_;
                iterator group_end(n.node_->group_prev_->next_);

                node_pointer first_node = creator.create(*n);
                node_pointer end = first_node;
                first_node->hash_ = key_hash;
                prev->next_ = first_node;
                ++dst.size_;

                for (++n; n != group_end; ++n)
                {
                    end = creator.create(*n);
                    end->hash_ = key_hash;
                    add_after_node(end, first_node);
                    ++dst.size_;
                }

                prev = place_in_bucket(dst, prev, end);
            }
        }


        void rehash_impl(std::size_t num_buckets)
        {
            ((this->buckets_) ? static_cast<void> (0) : __assert_fail ("this->buckets_", "/usr/include/boost/unordered/detail/equivalent.hpp", 649, __PRETTY_FUNCTION__));

            this->create_buckets(num_buckets);
            link_pointer prev = this->get_previous_start();
            while (prev->next_)
                prev = place_in_bucket(*this, prev,
                    static_cast<node_pointer>(prev->next_)->group_prev_);
        }



        static link_pointer place_in_bucket(table& dst,
                link_pointer prev, node_pointer end)
        {
            bucket_pointer b = dst.get_bucket(dst.hash_to_bucket(end->hash_));

            if (!b->next_) {
                b->next_ = prev;
                return end;
            }
            else {
                link_pointer next = end->next_;
                end->next_ = b->next_->next_;
                b->next_->next_ = prev->next_;
                prev->next_ = next;
                return prev;
            }
        }
    };
}}}
# 18 "/usr/include/boost/unordered/unordered_map.hpp" 2 3 4
# 1 "/usr/include/boost/unordered/detail/unique.hpp" 1 3 4
# 19 "/usr/include/boost/unordered/detail/unique.hpp" 3 4
namespace boost { namespace unordered { namespace detail {

    template <typename A, typename T> struct unique_node;
    template <typename T> struct ptr_node;
    template <typename Types> struct table_impl;

    template <typename A, typename T>
    struct unique_node :
        boost::unordered::detail::value_base<T>
    {
        typedef typename ::boost::unordered::detail::rebind_wrap<
            A, unique_node<A, T> >::type::pointer node_pointer;
        typedef node_pointer link_pointer;

        link_pointer next_;
        std::size_t hash_;

        unique_node() :
            next_(),
            hash_(0)
        {}

        void init(node_pointer)
        {
        }

    private:
        unique_node& operator=(unique_node const&);
    };

    template <typename T>
    struct ptr_node :
        boost::unordered::detail::value_base<T>,
        boost::unordered::detail::ptr_bucket
    {
        typedef boost::unordered::detail::ptr_bucket bucket_base;
        typedef ptr_node<T>* node_pointer;
        typedef ptr_bucket* link_pointer;

        std::size_t hash_;

        ptr_node() :
            bucket_base(),
            hash_(0)
        {}

        void init(node_pointer)
        {
        }

    private:
        ptr_node& operator=(ptr_node const&);
    };




    template <typename A, typename T, typename NodePtr, typename BucketPtr>
    struct pick_node2
    {
        typedef boost::unordered::detail::unique_node<A, T> node;

        typedef typename boost::unordered::detail::allocator_traits<
            typename boost::unordered::detail::rebind_wrap<A, node>::type
        >::pointer node_pointer;

        typedef boost::unordered::detail::bucket<node_pointer> bucket;
        typedef node_pointer link_pointer;
    };

    template <typename A, typename T>
    struct pick_node2<A, T,
        boost::unordered::detail::ptr_node<T>*,
        boost::unordered::detail::ptr_bucket*>
    {
        typedef boost::unordered::detail::ptr_node<T> node;
        typedef boost::unordered::detail::ptr_bucket bucket;
        typedef bucket* link_pointer;
    };

    template <typename A, typename T>
    struct pick_node
    {
        typedef boost::unordered::detail::allocator_traits<
            typename boost::unordered::detail::rebind_wrap<A,
                boost::unordered::detail::ptr_node<T> >::type
        > tentative_node_traits;

        typedef boost::unordered::detail::allocator_traits<
            typename boost::unordered::detail::rebind_wrap<A,
                boost::unordered::detail::ptr_bucket >::type
        > tentative_bucket_traits;

        typedef pick_node2<A, T,
            typename tentative_node_traits::pointer,
            typename tentative_bucket_traits::pointer> pick;

        typedef typename pick::node node;
        typedef typename pick::bucket bucket;
        typedef typename pick::link_pointer link_pointer;
    };

    template <typename A, typename T, typename H, typename P>
    struct set
    {
        typedef boost::unordered::detail::set<A, T, H, P> types;

        typedef A allocator;
        typedef T value_type;
        typedef H hasher;
        typedef P key_equal;
        typedef T key_type;

        typedef boost::unordered::detail::allocator_traits<allocator> traits;
        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
        typedef typename pick::node node;
        typedef typename pick::bucket bucket;
        typedef typename pick::link_pointer link_pointer;

        typedef boost::unordered::detail::table_impl<types> table;
        typedef boost::unordered::detail::set_extractor<value_type> extractor;

        typedef boost::unordered::detail::pick_policy::type policy;
    };

    template <typename A, typename K, typename M, typename H, typename P>
    struct map
    {
        typedef boost::unordered::detail::map<A, K, M, H, P> types;

        typedef A allocator;
        typedef std::pair<K const, M> value_type;
        typedef H hasher;
        typedef P key_equal;
        typedef K key_type;

        typedef boost::unordered::detail::allocator_traits<allocator>
            traits;
        typedef boost::unordered::detail::pick_node<allocator, value_type> pick;
        typedef typename pick::node node;
        typedef typename pick::bucket bucket;
        typedef typename pick::link_pointer link_pointer;

        typedef boost::unordered::detail::table_impl<types> table;
        typedef boost::unordered::detail::map_extractor<key_type, value_type>
            extractor;

        typedef boost::unordered::detail::pick_policy::type policy;
    };

    template <typename Types>
    struct table_impl : boost::unordered::detail::table<Types>
    {
        typedef boost::unordered::detail::table<Types> table;
        typedef typename table::value_type value_type;
        typedef typename table::bucket bucket;
        typedef typename table::policy policy;
        typedef typename table::node_pointer node_pointer;
        typedef typename table::node_allocator node_allocator;
        typedef typename table::node_allocator_traits node_allocator_traits;
        typedef typename table::bucket_pointer bucket_pointer;
        typedef typename table::link_pointer link_pointer;
        typedef typename table::hasher hasher;
        typedef typename table::key_equal key_equal;
        typedef typename table::key_type key_type;
        typedef typename table::node_constructor node_constructor;
        typedef typename table::extractor extractor;
        typedef typename table::iterator iterator;
        typedef typename table::c_iterator c_iterator;

        typedef std::pair<iterator, bool> emplace_return;



        table_impl(std::size_t n,
                hasher const& hf,
                key_equal const& eq,
                node_allocator const& a)
          : table(n, hf, eq, a)
        {}

        table_impl(table_impl const& x)
          : table(x, node_allocator_traits::
                select_on_container_copy_construction(x.node_alloc()))
        {
            this->init(x);
        }

        table_impl(table_impl const& x,
                node_allocator const& a)
          : table(x, a)
        {
            this->init(x);
        }

        table_impl(table_impl& x,
                boost::unordered::detail::move_tag m)
          : table(x, m)
        {}

        table_impl(table_impl& x,
                node_allocator const& a,
                boost::unordered::detail::move_tag m)
          : table(x, a, m)
        {
            this->move_init(x);
        }



        template <class Key, class Pred>
        iterator find_node_impl(
                std::size_t key_hash,
                Key const& k,
                Pred const& eq) const
        {
            std::size_t bucket_index = this->hash_to_bucket(key_hash);
            iterator n = this->begin(bucket_index);

            for (;;)
            {
                if (!n.node_) return n;

                std::size_t node_hash = n.node_->hash_;
                if (key_hash == node_hash)
                {
                    if (eq(k, this->get_key(*n)))
                        return n;
                }
                else
                {
                    if (this->hash_to_bucket(node_hash) != bucket_index)
                        return iterator();
                }

                ++n;
            }
        }

        std::size_t count(key_type const& k) const
        {
            return this->find_node(k).node_ ? 1 : 0;
        }

        value_type& at(key_type const& k) const
        {
            if (this->size_) {
                iterator it = this->find_node(k);
                if (it.node_) return *it;
            }

            boost::throw_exception(
                std::out_of_range("Unable to find key in unordered_map."));
        }

        std::pair<iterator, iterator>
            equal_range(key_type const& k) const
        {
            iterator n = this->find_node(k);
            iterator n2 = n;
            if (n2.node_) ++n2;
            return std::make_pair(n, n2);
        }



        bool equals(table_impl const& other) const
        {
            if(this->size_ != other.size_) return false;

            for(iterator n1 = this->begin(); n1.node_; ++n1)
            {
                iterator n2 = other.find_matching_node(n1);

                if (!n2.node_ || *n1 != *n2)
                    return false;
            }

            return true;
        }



        inline iterator add_node(
                node_constructor& a,
                std::size_t key_hash)
        {
            node_pointer n = a.release();
            n->hash_ = key_hash;

            bucket_pointer b = this->get_bucket(this->hash_to_bucket(key_hash));

            if (!b->next_)
            {
                link_pointer start_node = this->get_previous_start();

                if (start_node->next_) {
                    this->get_bucket(this->hash_to_bucket(
                        static_cast<node_pointer>(start_node->next_)->hash_)
                    )->next_ = n;
                }

                b->next_ = start_node;
                n->next_ = start_node->next_;
                start_node->next_ = n;
            }
            else
            {
                n->next_ = b->next_->next_;
                b->next_->next_ = n;
            }

            ++this->size_;
            return iterator(n);
        }

        value_type& operator[](key_type const& k)
        {
            typedef typename value_type::second_type mapped_type;

            std::size_t key_hash = this->hash(k);
            iterator pos = this->find_node(key_hash, k);

            if (pos.node_) return *pos;



            node_constructor a(this->node_alloc());
            a.construct_with_value(create_emplace_args(
                boost::unordered::piecewise_construct,
                boost::make_tuple(k),
                boost::make_tuple()));

            this->reserve_for_insert(this->size_ + 1);
            return *add_node(a, key_hash);
        }



        emplace_return emplace(boost::unordered::detail::emplace_args1<
                boost::unordered::detail::please_ignore_this_overload> const&)
        {
            ((false) ? static_cast<void> (0) : __assert_fail ("false", "/usr/include/boost/unordered/detail/unique.hpp", 361, __PRETTY_FUNCTION__));
            return emplace_return(this->begin(), false);
        }
# 374 "/usr/include/boost/unordered/detail/unique.hpp" 3 4
        template <typename Args>
        emplace_return emplace(Args const& args)
        {





            return emplace_impl(
                extractor::extract(args.a0, args.a1),
                args);

        }


        template <typename A0>
        emplace_return emplace(
                boost::unordered::detail::emplace_args1<A0> const& args)
        {
            return emplace_impl(extractor::extract(args.a0), args);
        }


        template <typename Args>
        emplace_return emplace_impl(key_type const& k,
            Args const& args)
        {
            std::size_t key_hash = this->hash(k);
            iterator pos = this->find_node(key_hash, k);

            if (pos.node_) return emplace_return(pos, false);



            node_constructor a(this->node_alloc());
            a.construct_with_value(args);



            this->reserve_for_insert(this->size_ + 1);
            return emplace_return(this->add_node(a, key_hash), true);
        }

        emplace_return emplace_impl_with_node(node_constructor& a)
        {
            key_type const& k = this->get_key(a.value());
            std::size_t key_hash = this->hash(k);
            iterator pos = this->find_node(key_hash, k);

            if (pos.node_) return emplace_return(pos, false);



            this->reserve_for_insert(this->size_ + 1);
            return emplace_return(this->add_node(a, key_hash), true);
        }

        template <typename Args>
        emplace_return emplace_impl(no_key, Args const& args)
        {


            node_constructor a(this->node_alloc());
            a.construct_with_value(args);
            return emplace_impl_with_node(a);
        }







        template <class InputIt>
        void insert_range(InputIt i, InputIt j)
        {
            if(i != j)
                return insert_range_impl(extractor::extract(*i), i, j);
        }

        template <class InputIt>
        void insert_range_impl(key_type const& k, InputIt i, InputIt j)
        {
            node_constructor a(this->node_alloc());

            insert_range_impl2(a, k, i, j);

            while(++i != j) {
# 470 "/usr/include/boost/unordered/detail/unique.hpp" 3 4
                insert_range_impl2(a, extractor::extract(*i), i, j);
            }
        }

        template <class InputIt>
        void insert_range_impl2(node_constructor& a, key_type const& k,
            InputIt i, InputIt j)
        {

            std::size_t key_hash = this->hash(k);
            iterator pos = this->find_node(key_hash, k);

            if (!pos.node_) {
                a.construct_with_value2(*i);
                if(this->size_ + 1 > this->max_load_)
                    this->reserve_for_insert(this->size_ +
                        boost::unordered::detail::insert_size(i, j));


                this->add_node(a, key_hash);
            }
        }

        template <class InputIt>
        void insert_range_impl(no_key, InputIt i, InputIt j)
        {
            node_constructor a(this->node_alloc());

            do {
                a.construct_with_value2(*i);
                emplace_impl_with_node(a);
            } while(++i != j);
        }






        std::size_t erase_key(key_type const& k)
        {
            if(!this->size_) return 0;

            std::size_t key_hash = this->hash(k);
            std::size_t bucket_index = this->hash_to_bucket(key_hash);
            link_pointer prev = this->get_previous_start(bucket_index);
            if (!prev) return 0;

            for (;;)
            {
                if (!prev->next_) return 0;
                std::size_t node_hash =
                    static_cast<node_pointer>(prev->next_)->hash_;
                if (this->hash_to_bucket(node_hash) != bucket_index)
                    return 0;
                if (node_hash == key_hash &&
                        this->key_eq()(k, this->get_key(
                        static_cast<node_pointer>(prev->next_)->value())))
                    break;
                prev = prev->next_;
            }

            link_pointer end = static_cast<node_pointer>(prev->next_)->next_;

            std::size_t count = this->delete_nodes(prev, end);
            this->fix_bucket(bucket_index, prev);
            return count;
        }

        iterator erase(c_iterator r)
        {
            ((r.node_) ? static_cast<void> (0) : __assert_fail ("r.node_", "/usr/include/boost/unordered/detail/unique.hpp", 541, __PRETTY_FUNCTION__));
            iterator next(r.node_);
            ++next;
            erase_nodes(r.node_, next.node_);
            return next;
        }

        iterator erase_range(c_iterator r1, c_iterator r2)
        {
            if (r1 == r2) return iterator(r2.node_);
            erase_nodes(r1.node_, r2.node_);
            return iterator(r2.node_);
        }

        void erase_nodes(node_pointer begin, node_pointer end)
        {
            std::size_t bucket_index = this->hash_to_bucket(begin->hash_);


            link_pointer prev = this->get_previous_start(bucket_index);
            while(prev->next_ != begin) prev = prev->next_;


            do {
                this->delete_node(prev);
                bucket_index = this->fix_bucket(bucket_index, prev);
            } while (prev->next_ != end);
        }




        template <class NodeCreator>
        static void fill_buckets(iterator n, table& dst,
            NodeCreator& creator)
        {
            link_pointer prev = dst.get_previous_start();

            while (n.node_) {
                node_pointer node = creator.create(*n);
                node->hash_ = n.node_->hash_;
                prev->next_ = node;
                ++dst.size_;
                ++n;

                prev = place_in_bucket(dst, prev);
            }
        }


        void rehash_impl(std::size_t num_buckets)
        {
            ((this->buckets_) ? static_cast<void> (0) : __assert_fail ("this->buckets_", "/usr/include/boost/unordered/detail/unique.hpp", 593, __PRETTY_FUNCTION__));

            this->create_buckets(num_buckets);
            link_pointer prev = this->get_previous_start();
            while (prev->next_)
                prev = place_in_bucket(*this, prev);
        }



        static link_pointer place_in_bucket(table& dst, link_pointer prev)
        {
            node_pointer n = static_cast<node_pointer>(prev->next_);
            bucket_pointer b = dst.get_bucket(dst.hash_to_bucket(n->hash_));

            if (!b->next_) {
                b->next_ = prev;
                return n;
            }
            else {
                prev->next_ = n->next_;
                n->next_ = b->next_->next_;
                b->next_->next_ = n;
                return prev;
            }
        }
    };
}}}
# 19 "/usr/include/boost/unordered/unordered_map.hpp" 2 3 4

# 1 "/usr/include/boost/functional/hash.hpp" 1 3 4





# 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
# 15 "/usr/include/boost/functional/hash/hash.hpp" 3 4
# 1 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 1 3 4
# 14 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 3 4
# 1 "/usr/include/boost/functional/hash/detail/float_functions.hpp" 1 3 4
# 76 "/usr/include/boost/functional/hash/detail/float_functions.hpp" 3 4
namespace boost {
    namespace hash_detail {
        template <typename Float>
        struct call_ldexp {
            typedef Float float_type;
            inline Float operator()(Float x, int y) const {
                return std::ldexp(x, y);
            }
        };

        template <typename Float>
        struct call_frexp {
            typedef Float float_type;
            inline Float operator()(Float x, int* y) const {
                return std::frexp(x, y);
            }
        };

        template <typename Float>
        struct select_hash_type
        {
            typedef Float type;
        };
    }
}
# 15 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
# 1 "/usr/include/boost/functional/hash/detail/limits.hpp" 1 3 4
# 26 "/usr/include/boost/functional/hash/detail/limits.hpp" 3 4
namespace boost
{
    namespace hash_detail
    {
        template <class T>
        struct limits : std::numeric_limits<T> {};
# 58 "/usr/include/boost/functional/hash/detail/limits.hpp" 3 4
    }
}
# 16 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4

# 1 "/usr/include/boost/integer/static_log2.hpp" 1 3 4
# 19 "/usr/include/boost/integer/static_log2.hpp" 3 4
# 1 "/usr/include/boost/integer_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/integer_fwd.hpp" 3 4
# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 13 "/usr/include/boost/integer_fwd.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 14 "/usr/include/boost/integer_fwd.hpp" 2 3 4



# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 18 "/usr/include/boost/integer_fwd.hpp" 2 3 4


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;
# 42 "/usr/include/boost/integer_fwd.hpp" 3 4
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 >;
# 97 "/usr/include/boost/integer_fwd.hpp" 3 4
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;

}
# 20 "/usr/include/boost/integer/static_log2.hpp" 2 3 4

namespace boost {

 namespace detail {

     namespace static_log2_impl {
# 44 "/usr/include/boost/integer/static_log2.hpp" 3 4
     typedef boost::static_log2_argument_type argument_type;
     typedef boost::static_log2_result_type result_type;

     template <result_type n>
     struct choose_initial_n {

         static const bool c = (argument_type(1) << n << n) != 0;
         static const result_type value = !c*n + choose_initial_n<2*c*n>::value


          ;

     };

     template <>
     struct choose_initial_n<0> {
         static const result_type value = 0;
     };




     const result_type n_zero = 16;
     const result_type initial_n = choose_initial_n<n_zero>::value;
# 84 "/usr/include/boost/integer/static_log2.hpp" 3 4
     template <argument_type x, result_type n = initial_n>
     struct static_log2_impl {

         static const bool c = (x >> n) > 0;
         static const result_type value = c*n + (static_log2_impl< (x>>c*n), n/2 >::value)


          ;

     };

     template <>
     struct static_log2_impl<1, 0> {
        static const result_type value = 0;
     };

     }
 }







 template <static_log2_argument_type x>
 struct static_log2 {

     static const static_log2_result_type value = detail::static_log2_impl::static_log2_impl<x>::value


      ;

 };


 template <>
 struct static_log2<0> { };

}
# 18 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 19 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 20 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 22 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 2 3 4
# 51 "/usr/include/boost/functional/hash/detail/hash_float.hpp" 3 4
namespace boost
{
    namespace hash_detail
    {
        inline void hash_float_combine(std::size_t& seed, std::size_t value)
        {
            seed ^= value + (seed<<6) + (seed>>2);
        }







        inline std::size_t hash_binary(char* ptr, std::size_t length)
        {
            std::size_t seed = 0;

            if (length >= sizeof(std::size_t)) {
                seed = *(std::size_t*) ptr;
                length -= sizeof(std::size_t);
                ptr += sizeof(std::size_t);

                while(length >= sizeof(std::size_t)) {
                    std::size_t buffer = 0;
                    std::memcpy(&buffer, ptr, sizeof(std::size_t));
                    hash_float_combine(seed, buffer);
                    length -= sizeof(std::size_t);
                    ptr += sizeof(std::size_t);
                }
            }

            if (length > 0) {
                std::size_t buffer = 0;
                std::memcpy(&buffer, ptr, length);
                hash_float_combine(seed, buffer);
            }

            return seed;
        }

        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                std::numeric_limits<Float>::is_iec559 &&
                std::numeric_limits<Float>::digits == 24 &&
                std::numeric_limits<Float>::radix == 2 &&
                std::numeric_limits<Float>::max_exponent == 128,
                int>::type
            )
        {
            return hash_binary((char*) &v, 4);
        }


        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                std::numeric_limits<Float>::is_iec559 &&
                std::numeric_limits<Float>::digits == 53 &&
                std::numeric_limits<Float>::radix == 2 &&
                std::numeric_limits<Float>::max_exponent == 1024,
                int>::type
            )
        {
            return hash_binary((char*) &v, 8);
        }

        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                std::numeric_limits<Float>::is_iec559 &&
                std::numeric_limits<Float>::digits == 64 &&
                std::numeric_limits<Float>::radix == 2 &&
                std::numeric_limits<Float>::max_exponent == 16384,
                int>::type
            )
        {
            return hash_binary((char*) &v, 10);
        }

        template <typename Float>
        inline std::size_t float_hash_impl(Float v,
            typename boost::enable_if_c<
                std::numeric_limits<Float>::is_iec559 &&
                std::numeric_limits<Float>::digits == 113 &&
                std::numeric_limits<Float>::radix == 2 &&
                std::numeric_limits<Float>::max_exponent == 16384,
                int>::type
            )
        {
            return hash_binary((char*) &v, 16);
        }






        template <class T>
        inline std::size_t float_hash_impl2(T v)
        {
            boost::hash_detail::call_frexp<T> frexp;
            boost::hash_detail::call_ldexp<T> ldexp;

            int exp = 0;

            v = frexp(v, &exp);



            if(v < 0) {
                v = -v;
                exp += limits<T>::max_exponent -
                    limits<T>::min_exponent;
            }

            v = ldexp(v, limits<std::size_t>::digits);
            std::size_t seed = static_cast<std::size_t>(v);
            v -= static_cast<T>(seed);


            std::size_t const length
                = (limits<T>::digits *
                        boost::static_log2<limits<T>::radix>::value
                        + limits<std::size_t>::digits - 1)
                / limits<std::size_t>::digits;

            for(std::size_t i = 0; i != length; ++i)
            {
                v = ldexp(v, limits<std::size_t>::digits);
                std::size_t part = static_cast<std::size_t>(v);
                v -= static_cast<T>(part);
                hash_float_combine(seed, part);
            }

            hash_float_combine(seed, exp);

            return seed;
        }


        template <class T>
        inline std::size_t float_hash_impl(T v, ...)
        {
            typedef typename select_hash_type<T>::type type;
            return float_hash_impl2(static_cast<type>(v));
        }

    }
}





namespace boost
{
    namespace hash_detail
    {
        template <class T>
        inline std::size_t float_hash_value(T v)
        {



            switch (std::fpclassify(v))




            {
            case 2:
                return 0;
            case 1:
                return (std::size_t)(v > 0 ? -1 : -2);
            case 0:
                return (std::size_t)(-3);
            case 4:
            case 3:
                return float_hash_impl(v, 0);
            default:
                ((0) ? static_cast<void> (0) : __assert_fail ("0", "/usr/include/boost/functional/hash/detail/hash_float.hpp", 234, __PRETTY_FUNCTION__));
                return 0;
            }
        }
    }
}
# 16 "/usr/include/boost/functional/hash/hash.hpp" 2 3 4
# 37 "/usr/include/boost/functional/hash/hash.hpp" 3 4
namespace boost
{
    namespace hash_detail
    {
        struct enable_hash_value { typedef std::size_t type; };

        template <typename T> struct basic_numbers {};
        template <typename T> struct long_numbers;
        template <typename T> struct ulong_numbers;
        template <typename T> struct float_numbers {};

        template <> struct basic_numbers<bool> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<char> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned char> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<signed char> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<short> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned short> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<int> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned int> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<long> :
            boost::hash_detail::enable_hash_value {};
        template <> struct basic_numbers<unsigned long> :
            boost::hash_detail::enable_hash_value {};


        template <> struct basic_numbers<wchar_t> :
            boost::hash_detail::enable_hash_value {};





        template <typename T> struct long_numbers2 {};
        template <typename T> struct ulong_numbers2 {};
        template <typename T> struct long_numbers : long_numbers2<T> {};
        template <typename T> struct ulong_numbers : ulong_numbers2<T> {};


        template <> struct long_numbers<boost::long_long_type> :
            boost::hash_detail::enable_hash_value {};
        template <> struct ulong_numbers<boost::ulong_long_type> :
            boost::hash_detail::enable_hash_value {};
# 96 "/usr/include/boost/functional/hash/hash.hpp" 3 4
        template <> struct float_numbers<float> :
            boost::hash_detail::enable_hash_value {};
        template <> struct float_numbers<double> :
            boost::hash_detail::enable_hash_value {};
        template <> struct float_numbers<long double> :
            boost::hash_detail::enable_hash_value {};
    }

    template <typename T>
    typename boost::hash_detail::basic_numbers<T>::type hash_value(T);
    template <typename T>
    typename boost::hash_detail::long_numbers<T>::type hash_value(T);
    template <typename T>
    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T);

    template <typename T>
    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
        hash_value(T);


    template <class T> std::size_t hash_value(T* const&);





    template< class T, unsigned N >
    std::size_t hash_value(const T (&x)[N]);

    template< class T, unsigned N >
    std::size_t hash_value(T (&x)[N]);


    template <class Ch, class A>
    std::size_t hash_value(
        std::basic_string<Ch, std::char_traits<Ch>, A> const&);

    template <typename T>
    typename boost::hash_detail::float_numbers<T>::type hash_value(T);







    namespace hash_detail
    {
        template <class T>
        inline std::size_t hash_value_signed(T val)
        {
             const int size_t_bits = std::numeric_limits<std::size_t>::digits;

             const int length = (std::numeric_limits<T>::digits - 1)
                 / size_t_bits;

             std::size_t seed = 0;
             T positive = val < 0 ? -1 - val : val;


             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
             {
                 seed ^= (std::size_t) (positive >> i) + (seed<<6) + (seed>>2);
             }
             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);

             return seed;
        }

        template <class T>
        inline std::size_t hash_value_unsigned(T val)
        {
             const int size_t_bits = std::numeric_limits<std::size_t>::digits;

             const int length = (std::numeric_limits<T>::digits - 1)
                 / size_t_bits;

             std::size_t seed = 0;


             for(unsigned int i = length * size_t_bits; i > 0; i -= size_t_bits)
             {
                 seed ^= (std::size_t) (val >> i) + (seed<<6) + (seed>>2);
             }
             seed ^= (std::size_t) val + (seed<<6) + (seed>>2);

             return seed;
        }
    }

    template <typename T>
    typename boost::hash_detail::basic_numbers<T>::type hash_value(T v)
    {
        return static_cast<std::size_t>(v);
    }

    template <typename T>
    typename boost::hash_detail::long_numbers<T>::type hash_value(T v)
    {
        return hash_detail::hash_value_signed(v);
    }

    template <typename T>
    typename boost::hash_detail::ulong_numbers<T>::type hash_value(T v)
    {
        return hash_detail::hash_value_unsigned(v);
    }

    template <typename T>
    typename boost::enable_if<boost::is_enum<T>, std::size_t>::type
        hash_value(T v)
    {
        return static_cast<std::size_t>(v);
    }



    template <class T> std::size_t hash_value(T* const& v)



    {






        std::size_t x = static_cast<std::size_t>(
           reinterpret_cast<std::ptrdiff_t>(v));

        return x + (x >> 3);
    }
# 244 "/usr/include/boost/functional/hash/hash.hpp" 3 4
    template <class T>
    inline void hash_combine(std::size_t& seed, T const& v)

    {
        boost::hash<T> hasher;
        seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
    }





    template <class It>
    inline std::size_t hash_range(It first, It last)
    {
        std::size_t seed = 0;

        for(; first != last; ++first)
        {
            hash_combine(seed, *first);
        }

        return seed;
    }

    template <class It>
    inline void hash_range(std::size_t& seed, It first, It last)
    {
        for(; first != last; ++first)
        {
            hash_combine(seed, *first);
        }
    }
# 305 "/usr/include/boost/functional/hash/hash.hpp" 3 4
    template< class T, unsigned N >
    inline std::size_t hash_value(const T (&x)[N])
    {
        return hash_range(x, x + N);
    }

    template< class T, unsigned N >
    inline std::size_t hash_value(T (&x)[N])
    {
        return hash_range(x, x + N);
    }


    template <class Ch, class A>
    inline std::size_t hash_value(
        std::basic_string<Ch, std::char_traits<Ch>, A> const& v)
    {
        return hash_range(v.begin(), v.end());
    }

    template <typename T>
    typename boost::hash_detail::float_numbers<T>::type hash_value(T v)
    {
        return boost::hash_detail::float_hash_value(v);
    }
# 414 "/usr/include/boost/functional/hash/hash.hpp" 3 4
    template <> struct hash<bool> : public std::unary_function<bool, std::size_t> { std::size_t operator()(bool v) const { return boost::hash_value(v); } };
    template <> struct hash<char> : public std::unary_function<char, std::size_t> { std::size_t operator()(char v) const { return boost::hash_value(v); } };
    template <> struct hash<signed char> : public std::unary_function<signed char, std::size_t> { std::size_t operator()(signed char v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned char> : public std::unary_function<unsigned char, std::size_t> { std::size_t operator()(unsigned char v) const { return boost::hash_value(v); } };

    template <> struct hash<wchar_t> : public std::unary_function<wchar_t, std::size_t> { std::size_t operator()(wchar_t v) const { return boost::hash_value(v); } };

    template <> struct hash<short> : public std::unary_function<short, std::size_t> { std::size_t operator()(short v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned short> : public std::unary_function<unsigned short, std::size_t> { std::size_t operator()(unsigned short v) const { return boost::hash_value(v); } };
    template <> struct hash<int> : public std::unary_function<int, std::size_t> { std::size_t operator()(int v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned int> : public std::unary_function<unsigned int, std::size_t> { std::size_t operator()(unsigned int v) const { return boost::hash_value(v); } };
    template <> struct hash<long> : public std::unary_function<long, std::size_t> { std::size_t operator()(long v) const { return boost::hash_value(v); } };
    template <> struct hash<unsigned long> : public std::unary_function<unsigned long, std::size_t> { std::size_t operator()(unsigned long v) const { return boost::hash_value(v); } };

    template <> struct hash<float> : public std::unary_function<float, std::size_t> { std::size_t operator()(float v) const { return boost::hash_value(v); } };
    template <> struct hash<double> : public std::unary_function<double, std::size_t> { std::size_t operator()(double v) const { return boost::hash_value(v); } };
    template <> struct hash<long double> : public std::unary_function<long double, std::size_t> { std::size_t operator()(long double v) const { return boost::hash_value(v); } };

    template <> struct hash<std::string> : public std::unary_function<std::string, std::size_t> { std::size_t operator()(std::string const& v) const { return boost::hash_value(v); } };

    template <> struct hash<std::wstring> : public std::unary_function<std::wstring, std::size_t> { std::size_t operator()(std::wstring const& v) const { return boost::hash_value(v); } };



    template <> struct hash<boost::long_long_type> : public std::unary_function<boost::long_long_type, std::size_t> { std::size_t operator()(boost::long_long_type v) const { return boost::hash_value(v); } };
    template <> struct hash<boost::ulong_long_type> : public std::unary_function<boost::ulong_long_type, std::size_t> { std::size_t operator()(boost::ulong_long_type v) const { return boost::hash_value(v); } };
# 458 "/usr/include/boost/functional/hash/hash.hpp" 3 4
    template <class T>
    struct hash<T*>
        : public std::unary_function<T*, std::size_t>
    {
        std::size_t operator()(T* v) const
        {

            return boost::hash_value(v);






        }
    };
# 517 "/usr/include/boost/functional/hash/hash.hpp" 3 4
}
# 529 "/usr/include/boost/functional/hash/hash.hpp" 3 4
# 1 "/usr/include/boost/functional/hash/extensions.hpp" 1 3 4
# 16 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
# 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
# 17 "/usr/include/boost/functional/hash/extensions.hpp" 2 3 4
# 1 "/usr/include/boost/detail/container_fwd.hpp" 1 3 4
# 91 "/usr/include/boost/detail/container_fwd.hpp" 3 4
# 1 "/usr/include/c++/4.8/deque" 1 3 4
# 58 "/usr/include/c++/4.8/deque" 3 4
       
# 59 "/usr/include/c++/4.8/deque" 3





# 1 "/usr/include/c++/4.8/bits/stl_deque.h" 1 3
# 66 "/usr/include/c++/4.8/bits/stl_deque.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 88 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  inline size_t
  __deque_buf_size(size_t __size)
  { return (__size < 512
     ? size_t(512 / __size) : size_t(1)); }
# 105 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  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); }
# 438 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  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)
      { }
# 482 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      ~_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);
 }
    }
# 579 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  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);
    }
# 729 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  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) { }
# 827 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      explicit
      deque(size_type __n, const value_type& __value = value_type(),
     const allocator_type& __a = allocator_type())
      : _Base(__a, __n)
      { _M_fill_initialize(__value); }
# 841 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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()); }
# 901 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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()); }
# 927 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      deque&
      operator=(const deque& __x);
# 977 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 1000 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      template<typename _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {
   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }
# 1027 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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); }
# 1141 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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(); }
# 1204 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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));
      }
# 1227 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      bool
      empty() const
      { return this->_M_impl._M_finish == this->_M_impl._M_start; }
# 1243 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      reference
      operator[](size_type __n)
      { return this->_M_impl._M_start[difference_type(__n)]; }
# 1258 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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:
# 1283 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1301 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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;
      }
# 1358 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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);
      }
# 1389 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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);
      }
# 1420 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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();
      }
# 1441 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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();
      }
# 1478 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1518 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      { _M_fill_insert(__position, __n, __x); }
# 1540 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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());
 }
# 1564 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      iterator
      erase(iterator __position);
# 1583 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1595 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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());
 }
# 1657 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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);
# 1679 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      void
      _M_fill_initialize(const value_type& __value);
# 1695 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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&);
# 1766 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      void _M_pop_back_aux();

      void _M_pop_front_aux();
# 1778 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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;
      }
# 1887 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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);
# 1923 "/usr/include/c++/4.8/bits/stl_deque.h" 3
      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);

    };
# 1955 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  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()); }
# 1973 "/usr/include/c++/4.8/bits/stl_deque.h" 3
  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); }




}
# 65 "/usr/include/c++/4.8/deque" 2 3

# 1 "/usr/include/c++/4.8/bits/deque.tcc" 1 3
# 59 "/usr/include/c++/4.8/bits/deque.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 90 "/usr/include/c++/4.8/bits/deque.tcc" 3
  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;
    }
# 146 "/usr/include/c++/4.8/bits/deque.tcc" 3
  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);
    }
# 191 "/usr/include/c++/4.8/bits/deque.tcc" 3
  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);
    }
# 348 "/usr/include/c++/4.8/bits/deque.tcc" 3
  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>
# 592 "/usr/include/c++/4.8/bits/deque.tcc" 3
    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;
    }
# 1065 "/usr/include/c++/4.8/bits/deque.tcc" 3

}
# 67 "/usr/include/c++/4.8/deque" 2 3
# 92 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/list" 1 3 4
# 58 "/usr/include/c++/4.8/list" 3 4
       
# 59 "/usr/include/c++/4.8/list" 3




# 1 "/usr/include/c++/4.8/bits/stl_list.h" 1 3
# 64 "/usr/include/c++/4.8/bits/stl_list.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
  namespace __detail
  {
 
# 77 "/usr/include/c++/4.8/bits/stl_list.h" 3
    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:
# 305 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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*>(&_M_impl); }

      const _Node_alloc_type&
      _M_get_Node_allocator() const
      { return *static_cast<const _Node_alloc_type*>(&_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 _Node_alloc_type& __a)
      : _M_impl(__a)
      { _M_init(); }
# 377 "/usr/include/c++/4.8/bits/stl_list.h" 3
      ~_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;
      }
    };
# 437 "/usr/include/c++/4.8/bits/stl_list.h" 3
  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;
      typedef typename _Base::_Node_alloc_type _Node_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;
# 481 "/usr/include/c++/4.8/bits/stl_list.h" 3
      _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;
      }
# 517 "/usr/include/c++/4.8/bits/stl_list.h" 3
    public:





      list()
      : _Base() { }





      explicit
      list(const allocator_type& __a)
      : _Base(_Node_alloc_type(__a)) { }
# 568 "/usr/include/c++/4.8/bits/stl_list.h" 3
      explicit
      list(size_type __n, const value_type& __value = value_type(),
    const allocator_type& __a = allocator_type())
      : _Base(_Node_alloc_type(__a))
      { _M_fill_initialize(__n, __value); }
# 582 "/usr/include/c++/4.8/bits/stl_list.h" 3
      list(const list& __x)
      : _Base(__x._M_get_Node_allocator())
      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
# 629 "/usr/include/c++/4.8/bits/stl_list.h" 3
      template<typename _InputIterator>
        list(_InputIterator __first, _InputIterator __last,
      const allocator_type& __a = allocator_type())
 : _Base(_Node_alloc_type(__a))
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_initialize_dispatch(__first, __last, _Integral());
 }
# 655 "/usr/include/c++/4.8/bits/stl_list.h" 3
      list&
      operator=(const list& __x);
# 701 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 724 "/usr/include/c++/4.8/bits/stl_list.h" 3
      template<typename _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {

   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }
# 748 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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()); }
# 867 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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(); }
# 917 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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;
      }
# 973 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      push_front(const value_type& __x)
      { this->_M_insert(begin(), __x); }
# 1000 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      pop_front()
      { this->_M_erase(begin()); }
# 1014 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      push_back(const value_type& __x)
      { this->_M_insert(end(), __x); }
# 1040 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      pop_back()
      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
# 1073 "/usr/include/c++/4.8/bits/stl_list.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1122 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      {
 list __tmp(__n, __x, get_allocator());
 splice(__position, __tmp);
      }
# 1146 "/usr/include/c++/4.8/bits/stl_list.h" 3
      template<typename _InputIterator>

        void
        insert(iterator __position, _InputIterator __first,
        _InputIterator __last)
        {
   list __tmp(__first, __last, get_allocator());
   splice(__position, __tmp);
 }
# 1171 "/usr/include/c++/4.8/bits/stl_list.h" 3
      iterator
      erase(iterator __position);
# 1192 "/usr/include/c++/4.8/bits/stl_list.h" 3
      iterator
      erase(iterator __first, iterator __last)
      {
 while (__first != __last)
   __first = erase(__first);
 return __last;
      }
# 1209 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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();
      }
# 1246 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void



      splice(iterator __position, list& __x)

      {
 if (!__x.empty())
   {
     _M_check_equal_allocators(__x);

     this->_M_transfer(__position, __x.begin(), __x.end());
   }
      }
# 1276 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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);
      }
# 1312 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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);
   }
      }
# 1347 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      remove(const _Tp& __value);
# 1361 "/usr/include/c++/4.8/bits/stl_list.h" 3
      template<typename _Predicate>
        void
        remove_if(_Predicate);
# 1375 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      unique();
# 1390 "/usr/include/c++/4.8/bits/stl_list.h" 3
      template<typename _BinaryPredicate>
        void
        unique(_BinaryPredicate);
# 1411 "/usr/include/c++/4.8/bits/stl_list.h" 3
      void
      merge(list& __x);
# 1438 "/usr/include/c++/4.8/bits/stl_list.h" 3
      template<typename _StrictWeakOrdering>
        void
        merge(list& __x, _StrictWeakOrdering __comp);







      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);
      }
# 1526 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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);
      }
# 1567 "/usr/include/c++/4.8/bits/stl_list.h" 3
      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"));
      }
    };
# 1600 "/usr/include/c++/4.8/bits/stl_list.h" 3
  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;
    }
# 1629 "/usr/include/c++/4.8/bits/stl_list.h" 3
  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); }


}
# 64 "/usr/include/c++/4.8/list" 2 3
# 1 "/usr/include/c++/4.8/bits/list.tcc" 1 3
# 59 "/usr/include/c++/4.8/bits/list.tcc" 3
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*>(_M_impl._M_node._M_next);
      while (__cur != &_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);
 }
    }
# 96 "/usr/include/c++/4.8/bits/list.tcc" 3
  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;
    }
# 166 "/usr/include/c++/4.8/bits/list.tcc" 3
  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));
   }
      }


}
# 65 "/usr/include/c++/4.8/list" 2 3
# 93 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4


# 1 "/usr/include/c++/4.8/set" 1 3 4
# 58 "/usr/include/c++/4.8/set" 3 4
       
# 59 "/usr/include/c++/4.8/set" 3


# 1 "/usr/include/c++/4.8/bits/stl_set.h" 1 3
# 64 "/usr/include/c++/4.8/bits/stl_set.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 88 "/usr/include/c++/4.8/bits/stl_set.h" 3
  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, _Key_alloc_type(__a)) { }
# 162 "/usr/include/c++/4.8/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_unique(__first, __last); }
# 179 "/usr/include/c++/4.8/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Key_alloc_type(__a))
        { _M_t._M_insert_unique(__first, __last); }
# 193 "/usr/include/c++/4.8/bits/stl_set.h" 3
      set(const set& __x)
      : _M_t(__x._M_t) { }
# 232 "/usr/include/c++/4.8/bits/stl_set.h" 3
      set&
      operator=(const set& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 280 "/usr/include/c++/4.8/bits/stl_set.h" 3
      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 allocator_type(_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(); }
# 367 "/usr/include/c++/4.8/bits/stl_set.h" 3
      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(); }
# 392 "/usr/include/c++/4.8/bits/stl_set.h" 3
      void
      swap(set& __x)
      { _M_t.swap(__x._M_t); }
# 459 "/usr/include/c++/4.8/bits/stl_set.h" 3
      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);
      }
# 496 "/usr/include/c++/4.8/bits/stl_set.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x)
      { return _M_t._M_insert_unique_(__position, __x); }
# 515 "/usr/include/c++/4.8/bits/stl_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_unique(__first, __last); }
# 564 "/usr/include/c++/4.8/bits/stl_set.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 580 "/usr/include/c++/4.8/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 618 "/usr/include/c++/4.8/bits/stl_set.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 629 "/usr/include/c++/4.8/bits/stl_set.h" 3
      void
      clear()
      { _M_t.clear(); }
# 643 "/usr/include/c++/4.8/bits/stl_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 661 "/usr/include/c++/4.8/bits/stl_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 682 "/usr/include/c++/4.8/bits/stl_set.h" 3
      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); }
# 698 "/usr/include/c++/4.8/bits/stl_set.h" 3
      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); }
# 723 "/usr/include/c++/4.8/bits/stl_set.h" 3
      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>&);
    };
# 752 "/usr/include/c++/4.8/bits/stl_set.h" 3
  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; }
# 769 "/usr/include/c++/4.8/bits/stl_set.h" 3
  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); }


}
# 62 "/usr/include/c++/4.8/set" 2 3
# 1 "/usr/include/c++/4.8/bits/stl_multiset.h" 1 3
# 64 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 90 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
  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, _Key_alloc_type(__a)) { }
# 159 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      template<typename _InputIterator>
        multiset(_InputIterator __first, _InputIterator __last)
 : _M_t()
        { _M_t._M_insert_equal(__first, __last); }
# 175 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      template<typename _InputIterator>
        multiset(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Key_alloc_type(__a))
        { _M_t._M_insert_equal(__first, __last); }
# 189 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      multiset(const multiset& __x)
      : _M_t(__x._M_t) { }
# 228 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      multiset&
      operator=(const multiset& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 277 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      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 allocator_type(_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(); }
# 364 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      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(); }
# 389 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      void
      swap(multiset& __x)
      { _M_t.swap(__x._M_t); }
# 453 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 483 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x)
      { return _M_t._M_insert_equal_(__position, __x); }
# 501 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      template<typename _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t._M_insert_equal(__first, __last); }
# 550 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 566 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 604 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 615 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      void
      clear()
      { _M_t.clear(); }
# 626 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 644 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 665 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      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); }
# 681 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      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); }
# 706 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
      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>&);
    };
# 737 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
  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; }
# 754 "/usr/include/c++/4.8/bits/stl_multiset.h" 3
  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); }


}
# 63 "/usr/include/c++/4.8/set" 2 3
# 96 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/bitset" 1 3 4
# 45 "/usr/include/c++/4.8/bitset" 3 4
       
# 46 "/usr/include/c++/4.8/bitset" 3
# 60 "/usr/include/c++/4.8/bitset" 3
namespace std __attribute__ ((__visibility__ ("default")))
{








  template<size_t _Nw>
    struct _Base_bitset
    {
      typedef unsigned long _WordT;


      _WordT _M_w[_Nw];

      _Base_bitset()
      : _M_w() { }
# 89 "/usr/include/c++/4.8/bitset" 3
      _Base_bitset(unsigned long __val)
      : _M_w()
      { _M_w[0] = __val; }


      static size_t
      _S_whichword(size_t __pos)
      { return __pos / (8 * 4); }

      static size_t
      _S_whichbyte(size_t __pos)
      { return (__pos % (8 * 4)) / 8; }

      static size_t
      _S_whichbit(size_t __pos)
      { return __pos % (8 * 4); }

      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;
      }

      template<size_t _Nb>
        bool
        _M_are_all() const
        {
   for (size_t __i = 0; __i < _Nw - 1; __i++)
     if (_M_w[__i] != ~static_cast<_WordT>(0))
       return false;
   return _M_hiword() == (~static_cast<_WordT>(0)
     >> (_Nw * (8 * 4)
         - _Nb));
 }

      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) const ;


      size_t
      _M_do_find_next(size_t, size_t) 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 * 4);
   const size_t __offset = __shift % (8 * 4);

   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 * 4)
        - __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 * 4);
   const size_t __offset = __shift % (8 * 4);
   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 * 4)
        - __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];
    }
# 314 "/usr/include/c++/4.8/bitset" 3
  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 * 4)
      + __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 * 4))
 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 * 4)
  + __builtin_ctzl(__thisword));


      __i++;
      for (; __i < _Nw; __i++)
 {
   __thisword = _M_w[__i];
   if (__thisword != static_cast<_WordT>(0))
     return (__i * (8 * 4)
      + __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 * 4); }

      static size_t
      _S_whichbyte(size_t __pos)
      { return (__pos % (8 * 4)) / 8; }

      static size_t
      _S_whichbit(size_t __pos)
      { return __pos % (8 * 4); }

      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; }

      template<size_t _Nb>
        bool
        _M_are_all() const
        { return _M_w == (~static_cast<_WordT>(0)
     >> ((8 * 4) - _Nb)); }

      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 * 4)))
   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 * 4); }

      static size_t
      _S_whichbyte(size_t __pos)
      { return (__pos % (8 * 4)) / 8; }

      static size_t
      _S_whichbit(size_t __pos)
      { return __pos % (8 * 4); }

      static _WordT
      _S_maskbit(size_t __pos)
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
# 556 "/usr/include/c++/4.8/bitset" 3
      _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; }

      template<size_t _Nb>
        bool
        _M_are_all() const
        { return true; }

      bool
      _M_is_any() const
      { return false; }

      size_t
      _M_do_count() const
      { return 0; }

      unsigned long
      _M_do_to_ulong() const
      { return 0; }
# 635 "/usr/include/c++/4.8/bitset" 3
      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) { }
    };
# 747 "/usr/include/c++/4.8/bitset" 3
  template<size_t _Nb>
    class bitset
    : private _Base_bitset<((_Nb) / (8 * 4) + ((_Nb) % (8 * 4) == 0 ? 0 : 1))>
    {
    private:
      typedef _Base_bitset<((_Nb) / (8 * 4) + ((_Nb) % (8 * 4) == 0 ? 0 : 1))> _Base;
      typedef unsigned long _WordT;

      void
      _M_do_sanitize()
      {
 typedef _Sanitize<_Nb % (8 * 4)> __sanitize_type;
 __sanitize_type::_S_do_sanitize(this->_M_hiword());
      }





    public:
# 779 "/usr/include/c++/4.8/bitset" 3
      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(); }
# 864 "/usr/include/c++/4.8/bitset" 3
      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'));
 }
# 888 "/usr/include/c++/4.8/bitset" 3
      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);
 }
# 950 "/usr/include/c++/4.8/bitset" 3
      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;
      }
# 979 "/usr/include/c++/4.8/bitset" 3
      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;
      }
# 1012 "/usr/include/c++/4.8/bitset" 3
      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;
      }
# 1092 "/usr/include/c++/4.8/bitset" 3
      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(); }
# 1144 "/usr/include/c++/4.8/bitset" 3
      reference
      operator[](size_t __position)
      { return reference(*this, __position); }

      bool
      operator[](size_t __position) const
      { return _Unchecked_test(__position); }
# 1159 "/usr/include/c++/4.8/bitset" 3
      unsigned long
      to_ulong() const
      { return this->_M_do_to_ulong(); }
# 1177 "/usr/include/c++/4.8/bitset" 3
      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); }
# 1302 "/usr/include/c++/4.8/bitset" 3
      bool
      test(size_t __position) const
      {
 if (__position >= _Nb)
   __throw_out_of_range(("bitset::test"));
 return _Unchecked_test(__position);
      }







      bool
      all() const
      { return this->template _M_are_all<_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; }
# 1353 "/usr/include/c++/4.8/bitset" 3
      size_t
      _Find_first() const
      { return this->_M_do_find_first(_Nb); }
# 1364 "/usr/include/c++/4.8/bitset" 3
      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, size_t(__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);
      }
# 1414 "/usr/include/c++/4.8/bitset" 3
  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;
    }
# 1451 "/usr/include/c++/4.8/bitset" 3
  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;
    }



}
# 97 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/complex" 1 3 4
# 39 "/usr/include/c++/4.8/complex" 3 4
       
# 40 "/usr/include/c++/4.8/complex" 3




# 1 "/usr/include/c++/4.8/cmath" 1 3
# 39 "/usr/include/c++/4.8/cmath" 3
       
# 40 "/usr/include/c++/4.8/cmath" 3
# 45 "/usr/include/c++/4.8/complex" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{

# 63 "/usr/include/c++/4.8/complex" 3
  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>&);
# 124 "/usr/include/c++/4.8/complex" 3
  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()) { }
# 154 "/usr/include/c++/4.8/complex" 3
      _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();
    }
# 546 "/usr/include/c++/4.8/complex" 3
  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()); }
# 604 "/usr/include/c++/4.8/complex" 3
  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()); }
# 634 "/usr/include/c++/4.8/complex" 3
  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()); }
# 765 "/usr/include/c++/4.8/complex" 3
  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()); }
# 857 "/usr/include/c++/4.8/complex" 3
  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()); }
# 901 "/usr/include/c++/4.8/complex" 3
  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()); }
# 929 "/usr/include/c++/4.8/complex" 3
  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()); }
# 959 "/usr/include/c++/4.8/complex" 3
  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, -(unsigned)__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>&);
# 1075 "/usr/include/c++/4.8/complex" 3
      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>&);
# 1226 "/usr/include/c++/4.8/complex" 3
      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()) { }
# 1378 "/usr/include/c++/4.8/complex" 3
      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;
    };


}
# 99 "/usr/include/boost/detail/container_fwd.hpp" 2 3 4
# 18 "/usr/include/boost/functional/hash/extensions.hpp" 2 3 4
# 47 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
namespace boost
{
    template <class A, class B>
    std::size_t hash_value(std::pair<A, B> const&);
    template <class T, class A>
    std::size_t hash_value(std::vector<T, A> const&);
    template <class T, class A>
    std::size_t hash_value(std::list<T, A> const& v);
    template <class T, class A>
    std::size_t hash_value(std::deque<T, A> const& v);
    template <class K, class C, class A>
    std::size_t hash_value(std::set<K, C, A> const& v);
    template <class K, class C, class A>
    std::size_t hash_value(std::multiset<K, C, A> const& v);
    template <class K, class T, class C, class A>
    std::size_t hash_value(std::map<K, T, C, A> const& v);
    template <class K, class T, class C, class A>
    std::size_t hash_value(std::multimap<K, T, C, A> const& v);

    template <class T>
    std::size_t hash_value(std::complex<T> const&);

    template <class A, class B>
    std::size_t hash_value(std::pair<A, B> const& v)
    {
        std::size_t seed = 0;
        boost::hash_combine(seed, v.first);
        boost::hash_combine(seed, v.second);
        return seed;
    }

    template <class T, class A>
    std::size_t hash_value(std::vector<T, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class T, class A>
    std::size_t hash_value(std::list<T, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class T, class A>
    std::size_t hash_value(std::deque<T, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class C, class A>
    std::size_t hash_value(std::set<K, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class C, class A>
    std::size_t hash_value(std::multiset<K, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class T, class C, class A>
    std::size_t hash_value(std::map<K, T, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class K, class T, class C, class A>
    std::size_t hash_value(std::multimap<K, T, C, A> const& v)
    {
        return boost::hash_range(v.begin(), v.end());
    }

    template <class T>
    std::size_t hash_value(std::complex<T> const& v)
    {
        boost::hash<T> hasher;
        std::size_t seed = hasher(v.imag());
        seed ^= hasher(v.real()) + (seed<<6) + (seed>>2);
        return seed;
    }
# 263 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
    template <class T> struct hash
        : std::unary_function<T, std::size_t>
    {

        std::size_t operator()(T const& val) const
        {
            return hash_value(val);
        }






    };
# 377 "/usr/include/boost/functional/hash/extensions.hpp" 3 4
}
# 530 "/usr/include/boost/functional/hash/hash.hpp" 2 3 4
# 7 "/usr/include/boost/functional/hash.hpp" 2 3 4
# 21 "/usr/include/boost/unordered/unordered_map.hpp" 2 3 4
# 36 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
namespace boost
{
namespace unordered
{
    template <class K, class T, class H, class P, class A>
    class unordered_map
    {




    public:

        typedef K key_type;
        typedef std::pair<const K, T> value_type;
        typedef T mapped_type;
        typedef H hasher;
        typedef P key_equal;
        typedef A allocator_type;

    private:

        typedef boost::unordered::detail::map<A, K, T, H, P> types;
        typedef typename types::traits allocator_traits;
        typedef typename types::table table;

    public:

        typedef typename allocator_traits::pointer pointer;
        typedef typename allocator_traits::const_pointer const_pointer;

        typedef value_type& reference;
        typedef value_type const& const_reference;

        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;

        typedef typename table::cl_iterator const_local_iterator;
        typedef typename table::l_iterator local_iterator;
        typedef typename table::c_iterator const_iterator;
        typedef typename table::iterator iterator;

    private:

        table table_;

    public:



        explicit unordered_map(
                size_type = boost::unordered::detail::default_bucket_count,
                const hasher& = hasher(),
                const key_equal& = key_equal(),
                const allocator_type& = allocator_type());

        explicit unordered_map(allocator_type const&);

        template <class InputIt>
        unordered_map(InputIt, InputIt);

        template <class InputIt>
        unordered_map(
                InputIt, InputIt,
                size_type,
                const hasher& = hasher(),
                const key_equal& = key_equal());

        template <class InputIt>
        unordered_map(
                InputIt, InputIt,
                size_type,
                const hasher&,
                const key_equal&,
                const allocator_type&);



        unordered_map(unordered_map const&);

        unordered_map(unordered_map const&, allocator_type const&);
# 145 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        ~unordered_map();
# 162 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        unordered_map& operator=(unordered_map const& x)
        {
            table_.assign(x.table_);
            return *this;
        }
# 181 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        allocator_type get_allocator() const
        {
            return table_.node_alloc();
        }



        bool empty() const
        {
            return table_.size_ == 0;
        }

        size_type size() const
        {
            return table_.size_;
        }

        size_type max_size() const;



        iterator begin()
        {
            return table_.begin();
        }

        const_iterator begin() const
        {
            return table_.begin();
        }

        iterator end()
        {
            return iterator();
        }

        const_iterator end() const
        {
            return const_iterator();
        }

        const_iterator cbegin() const
        {
            return table_.begin();
        }

        const_iterator cend() const
        {
            return const_iterator();
        }
# 254 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        std::pair<iterator, bool> emplace(
                boost::unordered::detail::empty_emplace
                    = boost::unordered::detail::empty_emplace(),
                value_type v = value_type())
        {
            return this->emplace(boost::move(v));
        }

        iterator emplace_hint(const_iterator hint,
                boost::unordered::detail::empty_emplace
                    = boost::unordered::detail::empty_emplace(),
                value_type v = value_type()
            )
        {
            return this->emplace_hint(hint, boost::move(v));
        }



        template <typename A0>
        std::pair<iterator, bool> emplace(const A0 & a0)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0))
            );
        }

        template <typename A0>
        iterator emplace_hint(const_iterator, const A0 & a0)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0))
            ).first;
        }

        template <typename A0, typename A1>
        std::pair<iterator, bool> emplace(
            const A0 & a0,
            const A1 & a1)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1))
            );
        }

        template <typename A0, typename A1>
        iterator emplace_hint(const_iterator,
            const A0 & a0,
            const A1 & a1)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1))
            ).first;
        }

        template <typename A0, typename A1, typename A2>
        std::pair<iterator, bool> emplace(
            const A0 & a0,
            const A1 & a1,
            const A2 & a2)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1),
                    boost::forward<A2>(a2))
            );
        }

        template <typename A0, typename A1, typename A2>
        iterator emplace_hint(const_iterator,
            const A0 & a0,
            const A1 & a1,
            const A2 & a2)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1),
                    boost::forward<A2>(a2))
            ).first;
        }
# 373 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        template < typename A0 , typename A1 , typename A2 , typename A3 > std::pair<iterator, bool> emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) )); } template < typename A0 , typename A1 , typename A2 , typename A3 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) )).first; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 > std::pair<iterator, bool> emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) )).first; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > std::pair<iterator, bool> emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) )).first; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 > std::pair<iterator, bool> emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 , const A6 & a6 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 , const A6 & a6 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) )).first; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 > std::pair<iterator, bool> emplace( 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 > iterator emplace_hint( const_iterator, 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) )).first; } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 > std::pair<iterator, bool> emplace( 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) , boost::forward<A8>(a8) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 > iterator emplace_hint( const_iterator, 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) , boost::forward<A8>(a8) )).first; }






        std::pair<iterator, bool> insert(value_type const& x)
        {
            return this->emplace(x);
        }

        std::pair<iterator, bool> insert(::boost::rv< value_type >& x)
        {
            return this->emplace(boost::move(x));
        }

        iterator insert(const_iterator hint, value_type const& x)
        {
            return this->emplace_hint(hint, x);
        }

        iterator insert(const_iterator hint, ::boost::rv< value_type >& x)
        {
            return this->emplace_hint(hint, boost::move(x));
        }

        template <class InputIt> void insert(InputIt, InputIt);





        iterator erase(const_iterator);
        size_type erase(const key_type&);
        iterator erase(const_iterator, const_iterator);
        void quick_erase(const_iterator it) { erase(it); }
        void erase_return_void(const_iterator it) { erase(it); }

        void clear();
        void swap(unordered_map&);



        hasher hash_function() const;
        key_equal key_eq() const;

        mapped_type& operator[](const key_type&);
        mapped_type& at(const key_type&);
        mapped_type const& at(const key_type&) const;



        iterator find(const key_type&);
        const_iterator find(const key_type&) const;

        template <class CompatibleKey, class CompatibleHash,
            class CompatiblePredicate>
        iterator find(
                CompatibleKey const&,
                CompatibleHash const&,
                CompatiblePredicate const&);

        template <class CompatibleKey, class CompatibleHash,
            class CompatiblePredicate>
        const_iterator find(
                CompatibleKey const&,
                CompatibleHash const&,
                CompatiblePredicate const&) const;

        size_type count(const key_type&) const;

        std::pair<iterator, iterator>
        equal_range(const key_type&);
        std::pair<const_iterator, const_iterator>
        equal_range(const key_type&) const;



        size_type bucket_count() const
        {
            return table_.bucket_count_;
        }

        size_type max_bucket_count() const
        {
            return table_.max_bucket_count();
        }

        size_type bucket_size(size_type) const;

        size_type bucket(const key_type& k) const
        {
            return table_.hash_to_bucket(table_.hash(k));
        }

        local_iterator begin(size_type n)
        {
            return local_iterator(
                table_.begin(n), n, table_.bucket_count_);
        }

        const_local_iterator begin(size_type n) const
        {
            return const_local_iterator(
                table_.begin(n), n, table_.bucket_count_);
        }

        local_iterator end(size_type)
        {
            return local_iterator();
        }

        const_local_iterator end(size_type) const
        {
            return const_local_iterator();
        }

        const_local_iterator cbegin(size_type n) const
        {
            return const_local_iterator(
                table_.begin(n), n, table_.bucket_count_);
        }

        const_local_iterator cend(size_type) const
        {
            return const_local_iterator();
        }



        float max_load_factor() const
        {
            return table_.mlf_;
        }

        float load_factor() const;
        void max_load_factor(float);
        void rehash(size_type);
        void reserve(size_type);


        friend bool operator==<K,T,H,P,A>(
                unordered_map const&, unordered_map const&);
        friend bool operator!=<K,T,H,P,A>(
                unordered_map const&, unordered_map const&);

    };

    template <class K, class T, class H, class P, class A>
    class unordered_multimap
    {



    public:

        typedef K key_type;
        typedef std::pair<const K, T> value_type;
        typedef T mapped_type;
        typedef H hasher;
        typedef P key_equal;
        typedef A allocator_type;

    private:

        typedef boost::unordered::detail::multimap<A, K, T, H, P> types;
        typedef typename types::traits allocator_traits;
        typedef typename types::table table;

    public:

        typedef typename allocator_traits::pointer pointer;
        typedef typename allocator_traits::const_pointer const_pointer;

        typedef value_type& reference;
        typedef value_type const& const_reference;

        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;

        typedef typename table::cl_iterator const_local_iterator;
        typedef typename table::l_iterator local_iterator;
        typedef typename table::c_iterator const_iterator;
        typedef typename table::iterator iterator;

    private:

        table table_;

    public:



        explicit unordered_multimap(
                size_type = boost::unordered::detail::default_bucket_count,
                const hasher& = hasher(),
                const key_equal& = key_equal(),
                const allocator_type& = allocator_type());

        explicit unordered_multimap(allocator_type const&);

        template <class InputIt>
        unordered_multimap(InputIt, InputIt);

        template <class InputIt>
        unordered_multimap(
                InputIt, InputIt,
                size_type,
                const hasher& = hasher(),
                const key_equal& = key_equal());

        template <class InputIt>
        unordered_multimap(
                InputIt, InputIt,
                size_type,
                const hasher&,
                const key_equal&,
                const allocator_type&);



        unordered_multimap(unordered_multimap const&);

        unordered_multimap(unordered_multimap const&, allocator_type const&);
# 626 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        ~unordered_multimap();
# 644 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        unordered_multimap& operator=(unordered_multimap const& x)
        {
            table_.assign(x.table_);
            return *this;
        }
# 663 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        allocator_type get_allocator() const
        {
            return table_.node_alloc();
        }



        bool empty() const
        {
            return table_.size_ == 0;
        }

        size_type size() const
        {
            return table_.size_;
        }

        size_type max_size() const;



        iterator begin()
        {
            return table_.begin();
        }

        const_iterator begin() const
        {
            return table_.begin();
        }

        iterator end()
        {
            return iterator();
        }

        const_iterator end() const
        {
            return const_iterator();
        }

        const_iterator cbegin() const
        {
            return table_.begin();
        }

        const_iterator cend() const
        {
            return const_iterator();
        }
# 736 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        iterator emplace(
                boost::unordered::detail::empty_emplace
                    = boost::unordered::detail::empty_emplace(),
                value_type v = value_type())
        {
            return this->emplace(boost::move(v));
        }

        iterator emplace_hint(const_iterator hint,
                boost::unordered::detail::empty_emplace
                    = boost::unordered::detail::empty_emplace(),
                value_type v = value_type()
            )
        {
            return this->emplace_hint(hint, boost::move(v));
        }



        template <typename A0>
        iterator emplace(const A0 & a0)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0))
            );
        }

        template <typename A0>
        iterator emplace_hint(const_iterator, const A0 & a0)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0))
            );
        }

        template <typename A0, typename A1>
        iterator emplace(
            const A0 & a0,
            const A1 & a1)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1))
            );
        }

        template <typename A0, typename A1>
        iterator emplace_hint(const_iterator,
            const A0 & a0,
            const A1 & a1)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1))
            );
        }

        template <typename A0, typename A1, typename A2>
        iterator emplace(
            const A0 & a0,
            const A1 & a1,
            const A2 & a2)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1),
                    boost::forward<A2>(a2))
            );
        }

        template <typename A0, typename A1, typename A2>
        iterator emplace_hint(const_iterator,
            const A0 & a0,
            const A1 & a1,
            const A2 & a2)
        {
            return table_.emplace(
                boost::unordered::detail::create_emplace_args(
                    boost::forward<A0>(a0),
                    boost::forward<A1>(a1),
                    boost::forward<A2>(a2))
            );
        }
# 855 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
        template < typename A0 , typename A1 , typename A2 , typename A3 > iterator emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) )); } template < typename A0 , typename A1 , typename A2 , typename A3 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 > iterator emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > iterator emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 > iterator emplace( const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 , const A6 & a6 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 > iterator emplace_hint( const_iterator, const A0 & a0 , const A1 & a1 , const A2 & a2 , const A3 & a3 , const A4 & a4 , const A5 & a5 , const A6 & a6 ) { return table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 > iterator emplace( 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 > iterator emplace_hint( const_iterator, 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 > iterator emplace( 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) , boost::forward<A8>(a8) )); } template < typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 > iterator emplace_hint( const_iterator, 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 table_.emplace( boost::unordered::detail::create_emplace_args( boost::forward<A0>(a0) , boost::forward<A1>(a1) , boost::forward<A2>(a2) , boost::forward<A3>(a3) , boost::forward<A4>(a4) , boost::forward<A5>(a5) , boost::forward<A6>(a6) , boost::forward<A7>(a7) , boost::forward<A8>(a8) )); }






        iterator insert(value_type const& x)
        {
            return this->emplace(x);
        }

        iterator insert(::boost::rv< value_type >& x)
        {
            return this->emplace(boost::move(x));
        }

        iterator insert(const_iterator hint, value_type const& x)
        {
            return this->emplace_hint(hint, x);
        }

        iterator insert(const_iterator hint, ::boost::rv< value_type >& x)
        {
            return this->emplace_hint(hint, boost::move(x));
        }

        template <class InputIt> void insert(InputIt, InputIt);





        iterator erase(const_iterator);
        size_type erase(const key_type&);
        iterator erase(const_iterator, const_iterator);
        void quick_erase(const_iterator it) { erase(it); }
        void erase_return_void(const_iterator it) { erase(it); }

        void clear();
        void swap(unordered_multimap&);



        hasher hash_function() const;
        key_equal key_eq() const;



        iterator find(const key_type&);
        const_iterator find(const key_type&) const;

        template <class CompatibleKey, class CompatibleHash,
            class CompatiblePredicate>
        iterator find(
                CompatibleKey const&,
                CompatibleHash const&,
                CompatiblePredicate const&);

        template <class CompatibleKey, class CompatibleHash,
            class CompatiblePredicate>
        const_iterator find(
                CompatibleKey const&,
                CompatibleHash const&,
                CompatiblePredicate const&) const;

        size_type count(const key_type&) const;

        std::pair<iterator, iterator>
        equal_range(const key_type&);
        std::pair<const_iterator, const_iterator>
        equal_range(const key_type&) const;



        size_type bucket_count() const
        {
            return table_.bucket_count_;
        }

        size_type max_bucket_count() const
        {
            return table_.max_bucket_count();
        }

        size_type bucket_size(size_type) const;

        size_type bucket(const key_type& k) const
        {
            return table_.hash_to_bucket(table_.hash(k));
        }

        local_iterator begin(size_type n)
        {
            return local_iterator(
                table_.begin(n), n, table_.bucket_count_);
        }

        const_local_iterator begin(size_type n) const
        {
            return const_local_iterator(
                table_.begin(n), n, table_.bucket_count_);
        }

        local_iterator end(size_type)
        {
            return local_iterator();
        }

        const_local_iterator end(size_type) const
        {
            return const_local_iterator();
        }

        const_local_iterator cbegin(size_type n) const
        {
            return const_local_iterator(
                table_.begin(n), n, table_.bucket_count_);
        }

        const_local_iterator cend(size_type) const
        {
            return const_local_iterator();
        }



        float max_load_factor() const
        {
            return table_.mlf_;
        }

        float load_factor() const;
        void max_load_factor(float);
        void rehash(size_type);
        void reserve(size_type);


        friend bool operator==<K,T,H,P,A>(
                unordered_multimap const&, unordered_multimap const&);
        friend bool operator!=<K,T,H,P,A>(
                unordered_multimap const&, unordered_multimap const&);

    };



    template <class K, class T, class H, class P, class A>
    unordered_map<K,T,H,P,A>::unordered_map(
            size_type n, const hasher &hf, const key_equal &eql,
            const allocator_type &a)
      : table_(n, hf, eql, a)
    {
    }

    template <class K, class T, class H, class P, class A>
    unordered_map<K,T,H,P,A>::unordered_map(allocator_type const& a)
      : table_(boost::unordered::detail::default_bucket_count,
            hasher(), key_equal(), a)
    {
    }

    template <class K, class T, class H, class P, class A>
    unordered_map<K,T,H,P,A>::unordered_map(
            unordered_map const& other, allocator_type const& a)
      : table_(other.table_, a)
    {
    }

    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    unordered_map<K,T,H,P,A>::unordered_map(InputIt f, InputIt l)
      : table_(boost::unordered::detail::initial_size(f, l),
        hasher(), key_equal(), allocator_type())
    {
        table_.insert_range(f, l);
    }

    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    unordered_map<K,T,H,P,A>::unordered_map(
            InputIt f, InputIt l,
            size_type n,
            const hasher &hf,
            const key_equal &eql)
      : table_(boost::unordered::detail::initial_size(f, l, n),
            hf, eql, allocator_type())
    {
        table_.insert_range(f, l);
    }

    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    unordered_map<K,T,H,P,A>::unordered_map(
            InputIt f, InputIt l,
            size_type n,
            const hasher &hf,
            const key_equal &eql,
            const allocator_type &a)
      : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
    {
        table_.insert_range(f, l);
    }

    template <class K, class T, class H, class P, class A>
    unordered_map<K,T,H,P,A>::~unordered_map() {}

    template <class K, class T, class H, class P, class A>
    unordered_map<K,T,H,P,A>::unordered_map(
            unordered_map const& other)
      : table_(other.table_)
    {
    }
# 1107 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
    template <class K, class T, class H, class P, class A>
    std::size_t unordered_map<K,T,H,P,A>::max_size() const
    {
        return table_.max_size();
    }



    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    void unordered_map<K,T,H,P,A>::insert(InputIt first, InputIt last)
    {
        table_.insert_range(first, last);
    }
# 1131 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::iterator
        unordered_map<K,T,H,P,A>::erase(const_iterator position)
    {
        return table_.erase(position);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::size_type
        unordered_map<K,T,H,P,A>::erase(const key_type& k)
    {
        return table_.erase_key(k);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::iterator
        unordered_map<K,T,H,P,A>::erase(
            const_iterator first, const_iterator last)
    {
        return table_.erase_range(first, last);
    }

    template <class K, class T, class H, class P, class A>
    void unordered_map<K,T,H,P,A>::clear()
    {
        table_.clear();
    }

    template <class K, class T, class H, class P, class A>
    void unordered_map<K,T,H,P,A>::swap(unordered_map& other)
    {
        table_.swap(other.table_);
    }



    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::hasher
        unordered_map<K,T,H,P,A>::hash_function() const
    {
        return table_.hash_function();
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::key_equal
        unordered_map<K,T,H,P,A>::key_eq() const
    {
        return table_.key_eq();
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::mapped_type&
        unordered_map<K,T,H,P,A>::operator[](const key_type &k)
    {
        return table_[k].second;
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::mapped_type&
        unordered_map<K,T,H,P,A>::at(const key_type& k)
    {
        return table_.at(k).second;
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::mapped_type const&
        unordered_map<K,T,H,P,A>::at(const key_type& k) const
    {
        return table_.at(k).second;
    }



    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::iterator
        unordered_map<K,T,H,P,A>::find(const key_type& k)
    {
        return table_.find_node(k);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::const_iterator
        unordered_map<K,T,H,P,A>::find(const key_type& k) const
    {
        return table_.find_node(k);
    }

    template <class K, class T, class H, class P, class A>
    template <class CompatibleKey, class CompatibleHash,
        class CompatiblePredicate>
    typename unordered_map<K,T,H,P,A>::iterator
        unordered_map<K,T,H,P,A>::find(
            CompatibleKey const& k,
            CompatibleHash const& hash,
            CompatiblePredicate const& eq)
    {
        return table_.generic_find_node(k, hash, eq);
    }

    template <class K, class T, class H, class P, class A>
    template <class CompatibleKey, class CompatibleHash,
        class CompatiblePredicate>
    typename unordered_map<K,T,H,P,A>::const_iterator
        unordered_map<K,T,H,P,A>::find(
            CompatibleKey const& k,
            CompatibleHash const& hash,
            CompatiblePredicate const& eq) const
    {
        return table_.generic_find_node(k, hash, eq);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::size_type
        unordered_map<K,T,H,P,A>::count(const key_type& k) const
    {
        return table_.count(k);
    }

    template <class K, class T, class H, class P, class A>
    std::pair<
            typename unordered_map<K,T,H,P,A>::iterator,
            typename unordered_map<K,T,H,P,A>::iterator>
        unordered_map<K,T,H,P,A>::equal_range(const key_type& k)
    {
        return table_.equal_range(k);
    }

    template <class K, class T, class H, class P, class A>
    std::pair<
            typename unordered_map<K,T,H,P,A>::const_iterator,
            typename unordered_map<K,T,H,P,A>::const_iterator>
        unordered_map<K,T,H,P,A>::equal_range(const key_type& k) const
    {
        return table_.equal_range(k);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_map<K,T,H,P,A>::size_type
        unordered_map<K,T,H,P,A>::bucket_size(size_type n) const
    {
        return table_.bucket_size(n);
    }



    template <class K, class T, class H, class P, class A>
    float unordered_map<K,T,H,P,A>::load_factor() const
    {
        return table_.load_factor();
    }

    template <class K, class T, class H, class P, class A>
    void unordered_map<K,T,H,P,A>::max_load_factor(float m)
    {
        table_.max_load_factor(m);
    }

    template <class K, class T, class H, class P, class A>
    void unordered_map<K,T,H,P,A>::rehash(size_type n)
    {
        table_.rehash(n);
    }

    template <class K, class T, class H, class P, class A>
    void unordered_map<K,T,H,P,A>::reserve(size_type n)
    {
        table_.reserve(n);
    }

    template <class K, class T, class H, class P, class A>
    inline bool operator==(
            unordered_map<K,T,H,P,A> const& m1,
            unordered_map<K,T,H,P,A> const& m2)
    {



        return m1.table_.equals(m2.table_);
    }

    template <class K, class T, class H, class P, class A>
    inline bool operator!=(
            unordered_map<K,T,H,P,A> const& m1,
            unordered_map<K,T,H,P,A> const& m2)
    {



        return !m1.table_.equals(m2.table_);
    }

    template <class K, class T, class H, class P, class A>
    inline void swap(
            unordered_map<K,T,H,P,A> &m1,
            unordered_map<K,T,H,P,A> &m2)
    {



        m1.swap(m2);
    }



    template <class K, class T, class H, class P, class A>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(
            size_type n, const hasher &hf, const key_equal &eql,
            const allocator_type &a)
      : table_(n, hf, eql, a)
    {
    }

    template <class K, class T, class H, class P, class A>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(allocator_type const& a)
      : table_(boost::unordered::detail::default_bucket_count,
            hasher(), key_equal(), a)
    {
    }

    template <class K, class T, class H, class P, class A>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(
            unordered_multimap const& other, allocator_type const& a)
      : table_(other.table_, a)
    {
    }

    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(InputIt f, InputIt l)
      : table_(boost::unordered::detail::initial_size(f, l),
        hasher(), key_equal(), allocator_type())
    {
        table_.insert_range(f, l);
    }

    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(
            InputIt f, InputIt l,
            size_type n,
            const hasher &hf,
            const key_equal &eql)
      : table_(boost::unordered::detail::initial_size(f, l, n),
            hf, eql, allocator_type())
    {
        table_.insert_range(f, l);
    }

    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(
            InputIt f, InputIt l,
            size_type n,
            const hasher &hf,
            const key_equal &eql,
            const allocator_type &a)
      : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
    {
        table_.insert_range(f, l);
    }

    template <class K, class T, class H, class P, class A>
    unordered_multimap<K,T,H,P,A>::~unordered_multimap() {}

    template <class K, class T, class H, class P, class A>
    unordered_multimap<K,T,H,P,A>::unordered_multimap(
            unordered_multimap const& other)
      : table_(other.table_)
    {
    }
# 1440 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
    template <class K, class T, class H, class P, class A>
    std::size_t unordered_multimap<K,T,H,P,A>::max_size() const
    {
        return table_.max_size();
    }



    template <class K, class T, class H, class P, class A>
    template <class InputIt>
    void unordered_multimap<K,T,H,P,A>::insert(InputIt first, InputIt last)
    {
        table_.insert_range(first, last);
    }
# 1464 "/usr/include/boost/unordered/unordered_map.hpp" 3 4
    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::iterator
        unordered_multimap<K,T,H,P,A>::erase(const_iterator position)
    {
        return table_.erase(position);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::size_type
        unordered_multimap<K,T,H,P,A>::erase(const key_type& k)
    {
        return table_.erase_key(k);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::iterator
        unordered_multimap<K,T,H,P,A>::erase(
            const_iterator first, const_iterator last)
    {
        return table_.erase_range(first, last);
    }

    template <class K, class T, class H, class P, class A>
    void unordered_multimap<K,T,H,P,A>::clear()
    {
        table_.clear();
    }

    template <class K, class T, class H, class P, class A>
    void unordered_multimap<K,T,H,P,A>::swap(unordered_multimap& other)
    {
        table_.swap(other.table_);
    }



    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::hasher
        unordered_multimap<K,T,H,P,A>::hash_function() const
    {
        return table_.hash_function();
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::key_equal
        unordered_multimap<K,T,H,P,A>::key_eq() const
    {
        return table_.key_eq();
    }



    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::iterator
        unordered_multimap<K,T,H,P,A>::find(const key_type& k)
    {
        return table_.find_node(k);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::const_iterator
        unordered_multimap<K,T,H,P,A>::find(const key_type& k) const
    {
        return table_.find_node(k);
    }

    template <class K, class T, class H, class P, class A>
    template <class CompatibleKey, class CompatibleHash,
        class CompatiblePredicate>
    typename unordered_multimap<K,T,H,P,A>::iterator
        unordered_multimap<K,T,H,P,A>::find(
            CompatibleKey const& k,
            CompatibleHash const& hash,
            CompatiblePredicate const& eq)
    {
        return table_.generic_find_node(k, hash, eq);
    }

    template <class K, class T, class H, class P, class A>
    template <class CompatibleKey, class CompatibleHash,
        class CompatiblePredicate>
    typename unordered_multimap<K,T,H,P,A>::const_iterator
        unordered_multimap<K,T,H,P,A>::find(
            CompatibleKey const& k,
            CompatibleHash const& hash,
            CompatiblePredicate const& eq) const
    {
        return table_.generic_find_node(k, hash, eq);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::size_type
        unordered_multimap<K,T,H,P,A>::count(const key_type& k) const
    {
        return table_.count(k);
    }

    template <class K, class T, class H, class P, class A>
    std::pair<
            typename unordered_multimap<K,T,H,P,A>::iterator,
            typename unordered_multimap<K,T,H,P,A>::iterator>
        unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k)
    {
        return table_.equal_range(k);
    }

    template <class K, class T, class H, class P, class A>
    std::pair<
            typename unordered_multimap<K,T,H,P,A>::const_iterator,
            typename unordered_multimap<K,T,H,P,A>::const_iterator>
        unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k) const
    {
        return table_.equal_range(k);
    }

    template <class K, class T, class H, class P, class A>
    typename unordered_multimap<K,T,H,P,A>::size_type
        unordered_multimap<K,T,H,P,A>::bucket_size(size_type n) const
    {
        return table_.bucket_size(n);
    }



    template <class K, class T, class H, class P, class A>
    float unordered_multimap<K,T,H,P,A>::load_factor() const
    {
        return table_.load_factor();
    }

    template <class K, class T, class H, class P, class A>
    void unordered_multimap<K,T,H,P,A>::max_load_factor(float m)
    {
        table_.max_load_factor(m);
    }

    template <class K, class T, class H, class P, class A>
    void unordered_multimap<K,T,H,P,A>::rehash(size_type n)
    {
        table_.rehash(n);
    }

    template <class K, class T, class H, class P, class A>
    void unordered_multimap<K,T,H,P,A>::reserve(size_type n)
    {
        table_.reserve(n);
    }

    template <class K, class T, class H, class P, class A>
    inline bool operator==(
            unordered_multimap<K,T,H,P,A> const& m1,
            unordered_multimap<K,T,H,P,A> const& m2)
    {



        return m1.table_.equals(m2.table_);
    }

    template <class K, class T, class H, class P, class A>
    inline bool operator!=(
            unordered_multimap<K,T,H,P,A> const& m1,
            unordered_multimap<K,T,H,P,A> const& m2)
    {



        return !m1.table_.equals(m2.table_);
    }

    template <class K, class T, class H, class P, class A>
    inline void swap(
            unordered_multimap<K,T,H,P,A> &m1,
            unordered_multimap<K,T,H,P,A> &m2)
    {



        m1.swap(m2);
    }

}
}
# 17 "/usr/include/boost/unordered_map.hpp" 2 3 4
# 25 "./drizzled/error.h" 2



# 1 "./drizzled/error/priority_t.h" 1
# 21 "./drizzled/error/priority_t.h"
       

namespace drizzled
{

namespace error
{

enum priority_t {
  EMERG,
  ALERT,
  CRITICAL,
  ERROR,
  WARN,
  INFO,
  INSPECT
};

}
}
# 29 "./drizzled/error.h" 2
# 1 "./drizzled/error_t.h" 1
# 21 "./drizzled/error_t.h"
       

namespace drizzled {

enum error_t {

  EE_OK=0,
  EE_ERROR_FIRST=1,
  EE_CANTCREATEFILE,
  EE_READ,
  EE_WRITE,
  EE_BADCLOSE,
  EE_OUTOFMEMORY,
  EE_DELETE,
  EE_LINK,
  EE_EOFERR,
  EE_CANTLOCK,
  EE_CANTUNLOCK,
  EE_DIR,
  EE_STAT,
  EE_CANT_CHSIZE,
  EE_CANT_OPEN_STREAM,
  EE_LINK_WARNING,
  EE_OPEN_WARNING,
  EE_DISK_FULL,
  EE_CANT_MKDIR,
  EE_UNKNOWN_CHARSET,
  EE_OUT_OF_FILERESOURCES,
  EE_CANT_READLINK,
  EE_CANT_SYMLINK,
  EE_REALPATH,
  EE_SYNC,
  EE_UNKNOWN_COLLATION,
  EE_FILENOTFOUND,
  EE_FILE_NOT_CLOSED,
  EE_ERROR_LAST= EE_FILE_NOT_CLOSED,

  HA_ERR_KEY_NOT_FOUND= 120,
  HA_ERR_FOUND_DUPP_KEY= 121,
  HA_ERR_INTERNAL_ERROR= 122,
  HA_ERR_RECORD_CHANGED= 123,
  HA_ERR_WRONG_INDEX= 124,
  HA_ERR_CRASHED= 126,
  HA_ERR_WRONG_IN_RECORD= 127,
  HA_ERR_OUT_OF_MEM= 128,
  HA_ERR_NOT_A_TABLE= 130,
  HA_ERR_WRONG_COMMAND= 131,
  HA_ERR_OLD_FILE= 132,
  HA_ERR_NO_ACTIVE_RECORD= 133,
  HA_ERR_RECORD_DELETED= 134,
  HA_ERR_RECORD_FILE_FULL= 135,
  HA_ERR_INDEX_FILE_FULL= 136,
  HA_ERR_END_OF_FILE= 137,
  HA_ERR_UNSUPPORTED= 138,
  HA_ERR_TO_BIG_ROW= 139,
  HA_WRONG_CREATE_OPTION= 140,
  HA_ERR_FOUND_DUPP_UNIQUE= 141,
  HA_ERR_UNKNOWN_CHARSET = 142,
  HA_ERR_WRONG_MRG_TABLE_DEF= 143,
  HA_ERR_CRASHED_ON_REPAIR=144,
  HA_ERR_CRASHED_ON_USAGE= 145,
  HA_ERR_LOCK_WAIT_TIMEOUT= 146,
  HA_ERR_LOCK_TABLE_FULL= 147,
  HA_ERR_READ_ONLY_TRANSACTION= 148,
  HA_ERR_LOCK_DEADLOCK = 149,
  HA_ERR_CANNOT_ADD_FOREIGN= 150,
  HA_ERR_NO_REFERENCED_ROW= 151,
  HA_ERR_ROW_IS_REFERENCED= 152,
  HA_ERR_NO_SAVEPOINT= 153,
  HA_ERR_NON_UNIQUE_BLOCK_SIZE= 154,
  HA_ERR_NO_SUCH_TABLE= 155,
  HA_ERR_TABLE_EXIST= 156,
  HA_ERR_NO_CONNECTION= 157,
  HA_ERR_NULL_IN_SPATIAL= 158,
  HA_ERR_TABLE_DEF_CHANGED= 159,
  HA_ERR_NO_PARTITION_FOUND= 160,
  HA_ERR_LOG_ROW_FOR_REPLICATION_FAILED= 161,
  HA_ERR_DROP_INDEX_FK= 162,
  HA_ERR_FOREIGN_DUPLICATE_KEY= 163,
  HA_ERR_TABLE_NEEDS_UPGRADE= 164,
  HA_ERR_TABLE_READONLY= 165,
  HA_ERR_AUTOINC_READ_FAILED= 166,
  HA_ERR_AUTOINC_ERANGE= 167,
  HA_ERR_GENERIC= 168,
  HA_ERR_RECORD_IS_THE_SAME= 169,
  HA_ERR_LOGGING_IMPOSSIBLE= 170,
  HA_ERR_TABLESPACE_EXIST= 171,
  HA_ERR_CORRUPT_EVENT= 172,
  HA_ERR_NEW_FILE= 173,
  HA_ERR_ROWS_EVENT_APPLY= 174,
  HA_ERR_INITIALIZATION= 175,
  HA_ERR_FILE_TOO_SHORT= 176,
  HA_ERR_WRONG_CRC= 177,
  HA_ERR_LOCK_OR_ACTIVE_TRANSACTION= 178,
  HA_ERR_NO_SUCH_TABLESPACE= 179,
  HA_ERR_TABLESPACE_NOT_EMPTY= 180,

  ER_ERROR_FIRST= 1000,
  ER_UNUSED1000= ER_ERROR_FIRST,
  ER_UNUSED1001,
  ER_NO,
  ER_YES,
  ER_CANT_CREATE_FILE,
  ER_CANT_CREATE_TABLE,
  ER_CANT_CREATE_DB,
  ER_DB_CREATE_EXISTS,
  ER_DB_DROP_EXISTS,
  ER_UNUSED1009,
  ER_UNUSED1010,
  ER_CANT_DELETE_FILE,
  ER_UNUSED1012,
  ER_CANT_GET_STAT,
  ER_UNUSED1014,
  ER_CANT_LOCK,
  ER_CANT_OPEN_FILE,
  ER_FILE_NOT_FOUND,
  ER_CANT_READ_DIR,
  ER_UNUSED1019,
  ER_CHECKREAD,
  ER_DISK_FULL,
  ER_DUP_KEY,
  ER_ERROR_ON_CLOSE,
  ER_ERROR_ON_READ,
  ER_ERROR_ON_RENAME,
  ER_ERROR_ON_WRITE,
  ER_FILE_USED,
  ER_FILSORT_ABORT,
  ER_UNUSED1029,
  ER_GET_ERRNO,
  ER_ILLEGAL_HA,
  ER_KEY_NOT_FOUND,
  ER_NOT_FORM_FILE,
  ER_NOT_KEYFILE,
  ER_OLD_KEYFILE,
  ER_OPEN_AS_READONLY,
  ER_OUTOFMEMORY,
  ER_OUT_OF_SORTMEMORY,
  ER_UNEXPECTED_EOF,
  ER_CON_COUNT_ERROR,
  ER_OUT_OF_RESOURCES,
  ER_BAD_HOST_ERROR,
  ER_HANDSHAKE_ERROR,
  ER_DBACCESS_DENIED_ERROR,
  ER_ACCESS_DENIED_ERROR,
  ER_NO_DB_ERROR,
  ER_UNKNOWN_COM_ERROR,
  ER_BAD_NULL_ERROR,
  ER_BAD_DB_ERROR,
  ER_TABLE_EXISTS_ERROR,
  ER_BAD_TABLE_ERROR,
  ER_NON_UNIQ_ERROR,
  ER_SERVER_SHUTDOWN,
  ER_BAD_FIELD_ERROR,
  ER_WRONG_FIELD_WITH_GROUP,
  ER_WRONG_GROUP_FIELD,
  ER_WRONG_SUM_SELECT,
  ER_WRONG_VALUE_COUNT,
  ER_TOO_LONG_IDENT,
  ER_DUP_FIELDNAME,
  ER_DUP_KEYNAME,
  ER_DUP_ENTRY,
  ER_WRONG_FIELD_SPEC,
  ER_PARSE_ERROR,
  ER_EMPTY_QUERY,
  ER_NONUNIQ_TABLE,
  ER_INVALID_DEFAULT,
  ER_MULTIPLE_PRI_KEY,
  ER_TOO_MANY_KEYS,
  ER_TOO_MANY_KEY_PARTS,
  ER_TOO_LONG_KEY,
  ER_KEY_COLUMN_DOES_NOT_EXITS,
  ER_BLOB_USED_AS_KEY,
  ER_TOO_BIG_FIELDLENGTH,
  ER_WRONG_AUTO_KEY,
  ER_UNUSED1076,
  ER_NORMAL_SHUTDOWN,
  ER_GOT_SIGNAL,
  ER_SHUTDOWN_COMPLETE,
  ER_FORCING_CLOSE,
  ER_IPSOCK_ERROR,
  ER_NO_SUCH_INDEX,
  ER_WRONG_FIELD_TERMINATORS,
  ER_BLOBS_AND_NO_TERMINATED,
  ER_TEXTFILE_NOT_READABLE,
  ER_FILE_EXISTS_ERROR,
  ER_LOAD_INFO,
  ER_UNUSED1088,
  ER_WRONG_SUB_KEY,
  ER_CANT_REMOVE_ALL_FIELDS,
  ER_CANT_DROP_FIELD_OR_KEY,
  ER_INSERT_INFO,
  ER_UPDATE_TABLE_USED,
  ER_NO_SUCH_THREAD,
  ER_KILL_DENIED_ERROR,
  ER_NO_TABLES_USED,
  ER_UNUSED1097,
  ER_UNUSED1098,
  ER_UNUSED1099,
  ER_UNUSED1100,
  ER_BLOB_CANT_HAVE_DEFAULT,
  ER_WRONG_DB_NAME,
  ER_WRONG_TABLE_NAME,
  ER_TOO_BIG_SELECT,
  ER_UNKNOWN_ERROR,
  ER_UNKNOWN_PROCEDURE,
  ER_WRONG_PARAMCOUNT_TO_PROCEDURE,
  ER_UNUSED1108,
  ER_UNKNOWN_TABLE,
  ER_FIELD_SPECIFIED_TWICE,
  ER_INVALID_GROUP_FUNC_USE,
  ER_UNSUPPORTED_EXTENSION,
  ER_TABLE_MUST_HAVE_COLUMNS,
  ER_RECORD_FILE_FULL,
  ER_UNUSED1115,
  ER_TOO_MANY_TABLES,
  ER_TOO_MANY_FIELDS,
  ER_TOO_BIG_ROWSIZE,
  ER_UNUSED1119,
  ER_WRONG_OUTER_JOIN,
  ER_NULL_COLUMN_IN_INDEX,
  ER_UNUSED1122,
  ER_UNUSED1123,
  ER_PLUGIN_NO_PATHS,
  ER_PLUGIN_EXISTS,
  ER_CANT_OPEN_LIBRARY,
  ER_CANT_FIND_DL_ENTRY,
  ER_UNUSED1128,
  ER_UNUSED1129,
  ER_UNUSED1130,
  ER_UNUSED1131,
  ER_UNUSED1132,
  ER_UNUSED1133,
  ER_UPDATE_INFO,
  ER_CANT_CREATE_THREAD,
  ER_WRONG_VALUE_COUNT_ON_ROW,
  ER_CANT_REOPEN_TABLE,
  ER_INVALID_USE_OF_NULL,
  ER_REGEXP_ERROR,
  ER_MIX_OF_GROUP_FUNC_AND_FIELDS,
  ER_NONEXISTING_GRANT,
  ER_TABLEACCESS_DENIED_ERROR,
  ER_COLUMNACCESS_DENIED_ERROR,
  ER_ILLEGAL_GRANT_FOR_TABLE,
  ER_GRANT_WRONG_HOST_OR_USER,
  ER_TABLE_UNKNOWN,
  ER_UNUSED1147,
  ER_UNUSED1148,
  ER_SYNTAX_ERROR,
  ER_UNUSED1150,
  ER_UNUSED1151,
  ER_UNUSED1152,
  ER_NET_PACKET_TOO_LARGE,
  ER_UNUSED1154,
  ER_UNUSED1155,
  ER_NET_PACKETS_OUT_OF_ORDER,
  ER_UNUSED1157,
  ER_UNUSED1158,
  ER_UNUSED1159,
  ER_UNUSED1160,
  ER_UNUSED1161,
  ER_UNUSED1162,
  ER_TABLE_CANT_HANDLE_BLOB,
  ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,
  ER_UNUSED1165,
  ER_WRONG_COLUMN_NAME,
  ER_WRONG_KEY_COLUMN,
  ER_WRONG_MRG_TABLE,
  ER_DUP_UNIQUE,
  ER_BLOB_KEY_WITHOUT_LENGTH,
  ER_PRIMARY_CANT_HAVE_NULL,
  ER_TOO_MANY_ROWS,
  ER_REQUIRES_PRIMARY_KEY,
  ER_UNUSED1174,
  ER_UNUSED1175,
  ER_KEY_DOES_NOT_EXITS,
  ER_CHECK_NO_SUCH_TABLE,
  ER_CHECK_NOT_IMPLEMENTED,
  ER_UNUSED1179,
  ER_ERROR_DURING_COMMIT,
  ER_ERROR_DURING_ROLLBACK,
  ER_UNUSED1182,
  ER_UNUSED1183,
  ER_NEW_ABORTING_CONNECTION,
  ER_UNUSED1185,
  ER_UNUSED1186,
  ER_UNUSED1187,
  ER_UNUSED1188,
  ER_UNUSED1189,
  ER_UNUSED1190,
  ER_UNUSED1191,
  ER_LOCK_OR_ACTIVE_TRANSACTION,
  ER_UNKNOWN_SYSTEM_VARIABLE,
  ER_CRASHED_ON_USAGE,
  ER_CRASHED_ON_REPAIR,
  ER_WARNING_NOT_COMPLETE_ROLLBACK,
  ER_UNUSED1197,
  ER_UNUSED1198,
  ER_UNUSED1199,
  ER_UNUSED1200,
  ER_UNUSED1201,
  ER_UNUSED1202,
  ER_UNUSED1203,
  ER_SET_CONSTANTS_ONLY,
  ER_LOCK_WAIT_TIMEOUT,
  ER_LOCK_TABLE_FULL,
  ER_READ_ONLY_TRANSACTION,
  ER_DROP_DB_WITH_READ_LOCK,
  ER_UNUSED1209,
  ER_WRONG_ARGUMENTS,
  ER_UNUSED1211,
  ER_UNUSED1212,
  ER_LOCK_DEADLOCK,
  ER_TABLE_CANT_HANDLE_FT,
  ER_CANNOT_ADD_FOREIGN,
  ER_NO_REFERENCED_ROW,
  ER_ROW_IS_REFERENCED,
  ER_UNUSED1218,
  ER_UNUSED1219,
  ER_UNUSED1220,
  ER_WRONG_USAGE,
  ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT,
  ER_CANT_UPDATE_WITH_READLOCK,
  ER_UNUSED1224,
  ER_UNUSED1225,
  ER_UNUSED1226,
  ER_UNUSED1227,
  ER_LOCAL_VARIABLE,
  ER_GLOBAL_VARIABLE,
  ER_NO_DEFAULT,
  ER_WRONG_VALUE_FOR_VAR,
  ER_WRONG_TYPE_FOR_VAR,
  ER_VAR_CANT_BE_READ,
  ER_CANT_USE_OPTION_HERE,
  ER_NOT_SUPPORTED_YET,
  ER_UNUSED1236,
  ER_UNUSED1237,
  ER_INCORRECT_GLOBAL_LOCAL_VAR,
  ER_WRONG_FK_DEF,
  ER_KEY_REF_DO_NOT_MATCH_TABLE_REF,
  ER_OPERAND_COLUMNS,
  ER_SUBQUERY_NO_1_ROW,
  ER_UNUSED1243,
  ER_UNUSED1244,
  ER_UNUSED1245,
  ER_AUTO_CONVERT,
  ER_ILLEGAL_REFERENCE,
  ER_DERIVED_MUST_HAVE_ALIAS,
  ER_SELECT_REDUCED,
  ER_TABLENAME_NOT_ALLOWED_HERE,
  ER_UNUSED1251,
  ER_SPATIAL_CANT_HAVE_NULL,
  ER_COLLATION_CHARSET_MISMATCH,
  ER_UNUSED1254,
  ER_UNUSED1255,
  ER_TOO_BIG_FOR_UNCOMPRESS,
  ER_ZLIB_Z_MEM_ERROR,
  ER_ZLIB_Z_BUF_ERROR,
  ER_ZLIB_Z_DATA_ERROR,
  ER_CUT_VALUE_GROUP_CONCAT,
  ER_WARN_TOO_FEW_RECORDS,
  ER_WARN_TOO_MANY_RECORDS,
  ER_WARN_NULL_TO_NOTNULL,
  ER_WARN_DATA_OUT_OF_RANGE,
  ER_WARN_DATA_TRUNCATED,
  ER_UNUSED1266,
  ER_CANT_AGGREGATE_2COLLATIONS,
  ER_UNUSED1268,
  ER_UNUSED1269,
  ER_CANT_AGGREGATE_3COLLATIONS,
  ER_CANT_AGGREGATE_NCOLLATIONS,
  ER_VARIABLE_IS_NOT_STRUCT,
  ER_UNKNOWN_COLLATION,
  ER_UNUSED1274,
  ER_UNUSED1275,
  ER_WARN_FIELD_RESOLVED,
  ER_UNUSED1277,
  ER_UNUSED1278,
  ER_UNUSED1279,
  ER_WRONG_NAME_FOR_INDEX,
  ER_WRONG_NAME_FOR_CATALOG,
  ER_UNUSED1282,
  ER_BAD_FT_COLUMN,
  ER_UNUSED1284,
  ER_UNUSED1285,
  ER_UNKNOWN_STORAGE_ENGINE,
  ER_UNUSED1287,
  ER_NON_UPDATABLE_TABLE,
  ER_FEATURE_DISABLED,
  ER_OPTION_PREVENTS_STATEMENT,
  ER_DUPLICATED_VALUE_IN_TYPE,
  ER_TRUNCATED_WRONG_VALUE,
  ER_TOO_MUCH_AUTO_TIMESTAMP_COLS,
  ER_INVALID_ON_UPDATE,
  ER_UNUSED1295,
  ER_GET_ERRMSG,
  ER_GET_TEMPORARY_ERRMSG,
  ER_UNKNOWN_TIME_ZONE,
  ER_UNUSED1299,
  ER_INVALID_CHARACTER_STRING,
  ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  ER_UNUSED1302,
  ER_UNUSED1303,
  ER_UNUSED1304,
  ER_SP_DOES_NOT_EXIST,
  ER_UNUSED1306,
  ER_UNUSED1307,
  ER_UNUSED1308,
  ER_UNUSED1309,
  ER_UNUSED1310,
  ER_UNUSED1311,
  ER_UNUSED1312,
  ER_UNUSED1313,
  ER_UNUSED1314,
  ER_UNUSED1315,
  ER_UNUSED1316,
  ER_QUERY_INTERRUPTED,
  ER_UNUSED1318,
  ER_UNUSED1319,
  ER_UNUSED1320,
  ER_UNUSED1321,
  ER_UNUSED1322,
  ER_UNUSED1323,
  ER_UNUSED1324,
  ER_UNUSED1325,
  ER_UNUSED1326,
  ER_UNUSED1327,
  ER_UNUSED1328,
  ER_SP_FETCH_NO_DATA,
  ER_UNUSED1330,
  ER_UNUSED1331,
  ER_UNUSED1332,
  ER_UNUSED1333,
  ER_UNUSED1334,
  ER_UNUSED1335,
  ER_UNUSED1336,
  ER_UNUSED1337,
  ER_UNUSED1338,
  ER_UNUSED1339,
  ER_UNUSED1340,
  ER_UNUSED1341,
  ER_UNUSED1342,
  ER_UNUSED1343,
  ER_UNUSED1344,
  ER_UNUSED1345,
  ER_UNUSED1346,
  ER_UNUSED1347,
  ER_UNUSED1348,
  ER_UNUSED1349,
  ER_UNUSED1350,
  ER_UNUSED1351,
  ER_UNUSED1352,
  ER_UNUSED1353,
  ER_UNUSED1354,
  ER_UNUSED1355,
  ER_VIEW_INVALID,
  ER_UNUSED1357,
  ER_UNUSED1358,
  ER_UNUSED1359,
  ER_UNUSED1360,
  ER_UNUSED1361,
  ER_UNUSED1362,
  ER_UNUSED1363,
  ER_NO_DEFAULT_FOR_FIELD,
  ER_DIVISION_BY_ZERO,
  ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
  ER_ILLEGAL_VALUE_FOR_TYPE,
  ER_UNUSED1368,
  ER_UNUSED1369,
  ER_UNUSED1370,
  ER_UNUSED1371,
  ER_UNUSED1372,
  ER_UNUSED1373,
  ER_UNUSED1374,
  ER_UNUSED1375,
  ER_UNUSED1376,
  ER_UNUSED1377,
  ER_UNUSED1378,
  ER_UNUSED1379,
  ER_UNUSED1380,
  ER_UNUSED1381,
  ER_UNUSED1382,
  ER_UNUSED1383,
  ER_UNUSED1384,
  ER_UNUSED1385,
  ER_UNUSED1386,
  ER_UNUSED1387,
  ER_UNUSED1388,
  ER_UNUSED1389,
  ER_UNUSED1390,
  ER_KEY_PART_0,
  ER_UNUSED1392,
  ER_UNUSED1393,
  ER_UNUSED1394,
  ER_UNUSED1395,
  ER_UNUSED1396,
  ER_UNUSED1397,
  ER_UNUSED1398,
  ER_XAER_RMFAIL,
  ER_UNUSED1400,
  ER_UNUSED1401,
  ER_UNUSED1402,
  ER_UNUSED1403,
  ER_UNUSED1404,
  ER_UNUSED1405,
  ER_DATA_TOO_LONG,
  ER_UNUSED1407,
  ER_STARTUP,
  ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR,
  ER_UNUSED1410,
  ER_WRONG_VALUE_FOR_TYPE,
  ER_TABLE_DEF_CHANGED,
  ER_UNUSED1413,
  ER_UNUSED1414,
  ER_SP_NO_RETSET,
  ER_CANT_CREATE_GEOMETRY_OBJECT,
  ER_UNUSED1417,
  ER_UNUSED1418,
  ER_UNUSED1419,
  ER_UNUSED1420,
  ER_UNUSED1421,
  ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG,
  ER_UNUSED1423,
  ER_UNUSED1424,
  ER_TOO_BIG_SCALE,
  ER_TOO_BIG_PRECISION,
  ER_M_BIGGER_THAN_D,
  ER_UNUSED1428,
  ER_UNUSED1429,
  ER_UNUSED1430,
  ER_UNUSED1431,
  ER_UNUSED1432,
  ER_UNUSED1433,
  ER_UNUSED1434,
  ER_TRG_IN_WRONG_SCHEMA,
  ER_STACK_OVERRUN_NEED_MORE=1436,
  ER_UNUSED1437,
  ER_UNUSED1438,
  ER_TOO_BIG_DISPLAYWIDTH,
  ER_UNUSED1440,
  ER_DATETIME_FUNCTION_OVERFLOW,
  ER_UNUSED1442,
  ER_UNUSED1443,
  ER_UNUSED1444,
  ER_UNUSED1445,
  ER_UNUSED1446,
  ER_UNUSED1447,
  ER_UNUSED1448,
  ER_UNUSED1449,
  ER_UNUSED1450,
  ER_ROW_IS_REFERENCED_2,
  ER_NO_REFERENCED_ROW_2,
  ER_UNUSED1453,
  ER_UNUSED1454,
  ER_UNUSED1455,
  ER_UNUSED1456,
  ER_UNUSED1457,
  ER_UNUSED1458,
  ER_TABLE_NEEDS_UPGRADE,
  ER_UNUSED1460,
  ER_UNUSED1461,
  ER_UNUSED1462,
  ER_NON_GROUPING_FIELD_USED,
  ER_TABLE_CANT_HANDLE_SPKEYS,
  ER_UNUSED1465,
  ER_REMOVED_SPACES,
  ER_AUTOINC_READ_FAILED,
  ER_UNUSED1468,
  ER_UNUSED1469,
  ER_WRONG_STRING_LENGTH,
  ER_UNUSED1471,
  ER_UNUSED1472,
  ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT,
  ER_NAME_BECOMES_EMPTY,
  ER_AMBIGUOUS_FIELD_TERM,
  ER_UNUSED1476,
  ER_UNUSED1477,
  ER_ILLEGAL_HA_CREATE_OPTION,
  ER_UNUSED1479,
  ER_UNUSED1480,
  ER_UNUSED1481,
  ER_UNUSED1482,
  ER_UNUSED1483,
  ER_UNUSED1484,
  ER_UNUSED1485,
  ER_UNUSED1486,
  ER_UNUSED1487,
  ER_UNUSED1488,
  ER_UNUSED1489,
  ER_UNUSED1490,
  ER_UNUSED1491,
  ER_UNUSED1492,
  ER_UNUSED1493,
  ER_UNUSED1494,
  ER_UNUSED1495,
  ER_UNUSED1496,
  ER_UNUSED1497,
  ER_UNUSED1498,
  ER_UNUSED1499,
  ER_UNUSED1500,
  ER_UNUSED1501,
  ER_UNUSED1502,
  ER_UNUSED1503,
  ER_UNUSED1504,
  ER_UNUSED1505,
  ER_UNUSED1506,
  ER_UNUSED1507,
  ER_UNUSED1508,
  ER_UNUSED1509,
  ER_UNUSED1510,
  ER_UNUSED1511,
  ER_UNUSED1512,
  ER_UNUSED1513,
  ER_UNUSED1514,
  ER_UNUSED1515,
  ER_UNUSED1516,
  ER_UNUSED1517,
  ER_UNUSED1518,
  ER_UNUSED1519,
  ER_UNUSED1520,
  ER_UNUSED1521,
  ER_UNUSED1522,
  ER_UNUSED1523,
  ER_INVALID_OPTION_VALUE,
  ER_WRONG_VALUE,
  ER_NO_PARTITION_FOR_GIVEN_VALUE,
  ER_UNUSED1527,
  ER_UNUSED1528,
  ER_UNUSED1529,
  ER_UNUSED1530,
  ER_UNUSED1531,
  ER_UNUSED1532,
  ER_UNUSED1533,
  ER_LOG_ROW_FOR_REPLICATION_FAILED,
  ER_UNUSED1535,
  ER_UNUSED1536,
  ER_UNUSED1537,
  ER_UNUSED1538,
  ER_UNUSED1539,
  ER_UNUSED1540,
  ER_UNUSED1541,
  ER_UNUSED1542,
  ER_UNUSED1543,
  ER_UNUSED1544,
  ER_UNUSED1545,
  ER_UNUSED1546,
  ER_UNUSED1547,
  ER_UNUSED1548,
  ER_UNUSED1549,
  ER_UNUSED1550,
  ER_UNUSED1551,
  ER_UNUSED1552,
  ER_DROP_INDEX_FK,
  ER_UNUSED1554,
  ER_UNUSED1555,
  ER_UNUSED1556,
  ER_FOREIGN_DUPLICATE_KEY,
  ER_UNUSED1558,
  ER_UNUSED1559,
  ER_UNUSED1560,
  ER_UNUSED1561,
  ER_UNUSED1562,
  ER_UNUSED1563,
  ER_UNUSED1564,
  ER_UNUSED1565,
  ER_UNUSED1566,
  ER_UNUSED1567,
  ER_CANT_CHANGE_TX_ISOLATION,
  ER_UNUSED1569,
  ER_UNUSED1570,
  ER_UNUSED1571,
  ER_UNUSED1572,
  ER_UNUSED1573,
  ER_UNUSED1574,
  ER_UNUSED1575,
  ER_UNUSED1576,
  ER_UNUSED1577,
  ER_UNUSED1578,
  ER_UNUSED1579,
  ER_UNUSED1580,
  ER_UNUSED1581,
  ER_WRONG_PARAMCOUNT_TO_FUNCTION,
  ER_WRONG_PARAMETERS_TO_NATIVE_FCT,
  ER_UNUSED1584,
  ER_UNUSED1585,
  ER_DUP_ENTRY_WITH_KEY_NAME,
  ER_UNUSED1587,
  ER_UNUSED1588,
  ER_UNUSED1589,
  ER_UNUSED1590,
  ER_UNUSED1591,
  ER_UNUSED1592,
  ER_UNUSED1593,
  ER_UNUSED1594,
  ER_UNUSED1595,
  ER_UNUSED1596,
  ER_UNUSED1597,
  ER_UNUSED1598,
  ER_UNUSED1599,
  ER_UNUSED1600,
  ER_UNUSED1601,
  ER_UNUSED1602,
  ER_UNUSED1603,
  ER_UNUSED1604,
  ER_UNUSED1605,
  ER_UNUSED1606,
  ER_UNUSED1607,
  ER_UNUSED1608,
  ER_UNUSED1609,
  ER_UNUSED1610,
  ER_LOAD_DATA_INVALID_COLUMN,
  ER_UNUSED1612,
  ER_UNUSED1613,
  ER_UNUSED1614,
  ER_UNUSED1615,
  ER_UNUSED1616,
  ER_UNUSED1617,
  ER_UNUSED1618,
  ER_UNUSED1619,
  ER_UNUSED1620,
  ER_UNUSED1621,
  ER_UNUSED1622,
  ER_UNUSED1623,
  ER_UNUSED1624,
  ER_UNUSED1625,
  ER_UNUSED1626,
  ER_UNUSED1627,
  ER_UNUSED1628,
  ER_UNUSED1629,
  ER_UNUSED1630,
  ER_UNUSED1631,
  ER_UNUSED1632,
  ER_UNUSED1633,
  ER_UNUSED1634,
  ER_UNUSED1635,
  ER_UNUSED1636,
  ER_UNUSED1637,
  ER_UNUSED1638,
  ER_UNUSED1639,
  ER_UNUSED1640,
  ER_UNUSED1641,
  ER_UNUSED1642,
  ER_UNUSED1643,
  ER_UNUSED1644,
  ER_UNUSED1645,
  ER_UNUSED1646,
  ER_UNUSED1647,
  ER_UNUSED1648,
  ER_UNUSED1649,
  ER_UNUSED1650,
  ER_UNUSED1651,
  ER_UNUSED1652,
  ER_UNUSED1653,
  ER_UNUSED1654,
  ER_UNUSED1655,
  ER_UNUSED1656,
  ER_UNUSED1657,
  ER_UNUSED1658,
  ER_UNUSED1659,
  ER_UNUSED1660,
  ER_UNUSED1661,
  ER_UNUSED1662,
  ER_UNUSED1663,
  ER_UNUSED1664,
  ER_UNUSED1665,
  ER_UNUSED1666,
  ER_UNUSED1667,
  ER_UNUSED1668,
  ER_UNUSED1669,
  ER_UNUSED1670,
  ER_UNUSED1671,
  ER_UNUSED1672,
  ER_UNUSED1673,
  ER_UNUSED1674,
  ER_UNUSED1675,
  ER_UNUSED1676,
  ER_UNUSED1677,
  ER_UNUSED1678,
  ER_UNUSED1679,
  ER_UNUSED1680,
  ER_UNUSED1681,
  ER_UNUSED1682,
  ER_UNUSED1683,
  ER_UNUSED1684,
  ER_INVALID_UNIX_TIMESTAMP_VALUE,
  ER_INVALID_DATETIME_VALUE,
  ER_INVALID_NULL_ARGUMENT,
  ER_UNUSED1688,
  ER_ARGUMENT_OUT_OF_RANGE,
  ER_UNUSED1690,
  ER_INVALID_ENUM_VALUE,
  ER_NO_PRIMARY_KEY_ON_REPLICATED_TABLE,
  ER_CORRUPT_TABLE_DEFINITION,
  ER_SCHEMA_DOES_NOT_EXIST,
  ER_ALTER_SCHEMA,
  ER_DROP_SCHEMA,
  ER_USE_SQL_BIG_RESULT,
  ER_UNKNOWN_ENGINE_OPTION,
  ER_UNKNOWN_SCHEMA_OPTION,
  ER_EVENT_OBSERVER_PLUGIN,
  ER_CORRUPT_SCHEMA_DEFINITION,
  ER_OUT_OF_GLOBAL_SORTMEMORY,
  ER_OUT_OF_GLOBAL_JOINMEMORY,
  ER_OUT_OF_GLOBAL_READRNDMEMORY,
  ER_OUT_OF_GLOBAL_READMEMORY,
  ER_USER_LOCKS_CANT_WAIT_ON_OWN_BARRIER,
  ER_USER_LOCKS_UNKNOWN_BARRIER,
  ER_USER_LOCKS_NOT_OWNER_OF_BARRIER,
  ER_USER_LOCKS_CANT_WAIT_ON_OWN_LOCK,
  ER_USER_LOCKS_NOT_OWNER_OF_LOCK,
  ER_USER_LOCKS_INVALID_NAME_BARRIER,
  ER_USER_LOCKS_INVALID_NAME_LOCK,
  ER_KILL_DENY_SELF_ERROR,
  ER_INVALID_ALTER_TABLE_FOR_NOT_NULL,
  ER_ADMIN_ACCESS,
  ER_ASSERT,
  ER_ASSERT_NULL,
  ER_CATALOG_CANNOT_CREATE,
  ER_CATALOG_CANNOT_CREATE_PERMISSION,
  ER_CATALOG_CANNOT_DROP,
  ER_CATALOG_CANNOT_DROP_PERMISSION,
  ER_CATALOG_DOES_NOT_EXIST,
  ER_CATALOG_NO_DROP_LOCAL,
  ER_CATALOG_NO_LOCK,
  ER_CORRUPT_CATALOG_DEFINITION,
  ER_CORRUPT_TABLE_DEFINITION_ENUM,
  ER_CORRUPT_TABLE_DEFINITION_UNKNOWN,
  ER_CORRUPT_TABLE_DEFINITION_UNKNOWN_COLLATION,
  ER_INVALID_BOOLEAN_VALUE,
  ER_INVALID_CAST_TO_SIGNED,
  ER_INVALID_CAST_TO_UNSIGNED,
  ER_INVALID_UUID_TIME,
  ER_INVALID_UUID_VALUE,
  ER_INVALID_IPV6_VALUE,
  ER_SQL_KEYWORD,
  ER_TABLE_DROP,
  ER_TABLE_DROP_ERROR_OCCURRED,
  ER_TABLE_PERMISSION_DENIED,
  ER_INVALID_TIMESTAMP_VALUE,

  ER_SCHEMA_CANNOT_CREATE,
  ER_PARSE_ERROR_UNKNOWN,
  ER_INVALID_CAST_TO_BOOLEAN,
  ER_INVALID_TIME_VALUE,
  ER_INVALID_DATE_VALUE,
  ER_TRANSACTIONAL_DDL_NOT_SUPPORTED,
  ER_USE_DATA_DICTIONARY,
  ER_TRANSACTION_ALREADY_STARTED,
  ER_CARTESIAN_JOIN_ATTEMPTED,
  ER_NO_LOCK_HELD,
  ER_SCRIPT
};


}
# 30 "./drizzled/error.h" 2
# 1 "./drizzled/identifier.h" 1
# 21 "./drizzled/identifier.h"
       





namespace drizzled {

class __attribute__ ((visibility("default"))) Identifier
{
public:
  virtual ~Identifier()
  {
 }

 virtual std::string getSQLPath() const
 {
  return "";
 }
};

}

# 1 "./drizzled/identifier/catalog.h" 1
# 21 "./drizzled/identifier/catalog.h"
       




# 1 "/usr/include/c++/4.8/cstring" 1 3
# 39 "/usr/include/c++/4.8/cstring" 3
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 27 "./drizzled/identifier/catalog.h" 2
# 1 "/usr/include/c++/4.8/cassert" 1 3
# 41 "/usr/include/c++/4.8/cassert" 3
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 28 "./drizzled/identifier/catalog.h" 2





# 1 "/usr/include/boost/algorithm/string.hpp" 1 3 4
# 18 "/usr/include/boost/algorithm/string.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/std_containers_traits.hpp" 1 3 4
# 19 "/usr/include/boost/algorithm/string/std_containers_traits.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/std/string_traits.hpp" 1 3 4
# 14 "/usr/include/boost/algorithm/string/std/string_traits.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/yes_no_type.hpp" 1 3 4
# 14 "/usr/include/boost/algorithm/string/yes_no_type.hpp" 3 4
namespace boost {
    namespace algorithm {





        template<int I> struct size_descriptor
        {
            typedef char (& type)[I];
        };

        typedef size_descriptor<1>::type yes_type;
        typedef size_descriptor<2>::type no_type;

    }
}
# 15 "/usr/include/boost/algorithm/string/std/string_traits.hpp" 2 3 4

# 1 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 1 3 4
# 34 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
namespace boost {
    namespace algorithm {
# 85 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
        template< typename T >
        class has_native_replace
        {
# 96 "/usr/include/boost/algorithm/string/sequence_traits.hpp" 3 4
        public:



            static const bool value=false;




            typedef mpl::bool_<has_native_replace<T>::value> type;
        };







        template< typename T >
        class has_stable_iterators
        {







        public:



            static const bool value=false;



            typedef mpl::bool_<has_stable_iterators<T>::value> type;
        };







        template< typename T >
        class has_const_time_insert
        {







        public:



            static const bool value=false;



            typedef mpl::bool_<has_const_time_insert<T>::value> type;
        };







        template< typename T >
        class has_const_time_erase
        {







        public:



            static const bool value=false;



            typedef mpl::bool_<has_const_time_erase<T>::value> type;
        };

    }
}
# 17 "/usr/include/boost/algorithm/string/std/string_traits.hpp" 2 3 4

namespace boost {
    namespace algorithm {
# 32 "/usr/include/boost/algorithm/string/std/string_traits.hpp" 3 4
        template<typename T, typename TraitsT, typename AllocT>
        class has_native_replace< std::basic_string<T, TraitsT, AllocT> >
        {
        public:



            static const bool value=true;


        typedef mpl::bool_<has_native_replace<T>::value> type;
        };




    }
}
# 20 "/usr/include/boost/algorithm/string/std_containers_traits.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/std/list_traits.hpp" 1 3 4
# 18 "/usr/include/boost/algorithm/string/std/list_traits.hpp" 3 4
namespace boost {
    namespace algorithm {
# 41 "/usr/include/boost/algorithm/string/std/list_traits.hpp" 3 4
        template<typename T, typename AllocT>
        class has_stable_iterators< ::std::list<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_stable_iterators<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_insert< ::std::list<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_insert<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_erase< ::std::list<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_erase<T>::value> type;
        };



    }
}
# 21 "/usr/include/boost/algorithm/string/std_containers_traits.hpp" 2 3 4


# 1 "/usr/include/boost/algorithm/string/std/slist_traits.hpp" 1 3 4
# 14 "/usr/include/boost/algorithm/string/std/slist_traits.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/config.hpp" 1 3 4
# 15 "/usr/include/boost/algorithm/string/std/slist_traits.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/ext/slist" 1 3 4
# 53 "/usr/include/c++/4.8/ext/slist" 3 4
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


  using std::size_t;
  using std::ptrdiff_t;
  using std::_Construct;
  using std::_Destroy;
  using std::allocator;
  using std::__true_type;
  using std::__false_type;

  struct _Slist_node_base
  {
    _Slist_node_base* _M_next;
  };

  inline _Slist_node_base*
  __slist_make_link(_Slist_node_base* __prev_node,
      _Slist_node_base* __new_node)
  {
    __new_node->_M_next = __prev_node->_M_next;
    __prev_node->_M_next = __new_node;
    return __new_node;
  }

  inline _Slist_node_base*
  __slist_previous(_Slist_node_base* __head,
     const _Slist_node_base* __node)
  {
    while (__head && __head->_M_next != __node)
      __head = __head->_M_next;
    return __head;
  }

  inline const _Slist_node_base*
  __slist_previous(const _Slist_node_base* __head,
     const _Slist_node_base* __node)
  {
    while (__head && __head->_M_next != __node)
      __head = __head->_M_next;
    return __head;
  }

  inline void
  __slist_splice_after(_Slist_node_base* __pos,
         _Slist_node_base* __before_first,
         _Slist_node_base* __before_last)
  {
    if (__pos != __before_first && __pos != __before_last)
      {
 _Slist_node_base* __first = __before_first->_M_next;
 _Slist_node_base* __after = __pos->_M_next;
 __before_first->_M_next = __before_last->_M_next;
 __pos->_M_next = __first;
 __before_last->_M_next = __after;
      }
  }

  inline void
  __slist_splice_after(_Slist_node_base* __pos, _Slist_node_base* __head)
  {
    _Slist_node_base* __before_last = __slist_previous(__head, 0);
    if (__before_last != __head)
      {
 _Slist_node_base* __after = __pos->_M_next;
 __pos->_M_next = __head->_M_next;
 __head->_M_next = 0;
 __before_last->_M_next = __after;
      }
  }

  inline _Slist_node_base*
  __slist_reverse(_Slist_node_base* __node)
  {
    _Slist_node_base* __result = __node;
    __node = __node->_M_next;
    __result->_M_next = 0;
    while(__node)
      {
 _Slist_node_base* __next = __node->_M_next;
 __node->_M_next = __result;
 __result = __node;
 __node = __next;
      }
    return __result;
  }

  inline size_t
  __slist_size(_Slist_node_base* __node)
  {
    size_t __result = 0;
    for (; __node != 0; __node = __node->_M_next)
      ++__result;
    return __result;
  }

  template <class _Tp>
    struct _Slist_node : public _Slist_node_base
    {
      _Tp _M_data;
    };

  struct _Slist_iterator_base
  {
    typedef size_t size_type;
    typedef ptrdiff_t difference_type;
    typedef std::forward_iterator_tag iterator_category;

    _Slist_node_base* _M_node;

    _Slist_iterator_base(_Slist_node_base* __x)
    : _M_node(__x) {}

    void
    _M_incr()
    { _M_node = _M_node->_M_next; }

    bool
    operator==(const _Slist_iterator_base& __x) const
    { return _M_node == __x._M_node; }

    bool
    operator!=(const _Slist_iterator_base& __x) const
    { return _M_node != __x._M_node; }
  };

  template <class _Tp, class _Ref, class _Ptr>
    struct _Slist_iterator : public _Slist_iterator_base
    {
      typedef _Slist_iterator<_Tp, _Tp&, _Tp*> iterator;
      typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;
      typedef _Slist_iterator<_Tp, _Ref, _Ptr> _Self;

      typedef _Tp value_type;
      typedef _Ptr pointer;
      typedef _Ref reference;
      typedef _Slist_node<_Tp> _Node;

      explicit
      _Slist_iterator(_Node* __x)
      : _Slist_iterator_base(__x) {}

      _Slist_iterator()
      : _Slist_iterator_base(0) {}

      _Slist_iterator(const iterator& __x)
      : _Slist_iterator_base(__x._M_node) {}

      reference
      operator*() const
      { return ((_Node*) _M_node)->_M_data; }

      pointer
      operator->() const
      { return &(operator*()); }

      _Self&
      operator++()
      {
 _M_incr();
 return *this;
      }

      _Self
      operator++(int)
      {
 _Self __tmp = *this;
 _M_incr();
 return __tmp;
      }
    };

  template <class _Tp, class _Alloc>
    struct _Slist_base
    : public _Alloc::template rebind<_Slist_node<_Tp> >::other
    {
      typedef typename _Alloc::template rebind<_Slist_node<_Tp> >::other
        _Node_alloc;
      typedef _Alloc allocator_type;

      allocator_type
      get_allocator() const
      { return *static_cast<const _Node_alloc*>(this); }

      _Slist_base(const allocator_type& __a)
      : _Node_alloc(__a)
      { this->_M_head._M_next = 0; }

      ~_Slist_base()
      { _M_erase_after(&this->_M_head, 0); }

    protected:
      _Slist_node_base _M_head;

      _Slist_node<_Tp>*
      _M_get_node()
      { return _Node_alloc::allocate(1); }

      void
      _M_put_node(_Slist_node<_Tp>* __p)
      { _Node_alloc::deallocate(__p, 1); }

    protected:
      _Slist_node_base* _M_erase_after(_Slist_node_base* __pos)
      {
 _Slist_node<_Tp>* __next = (_Slist_node<_Tp>*) (__pos->_M_next);
 _Slist_node_base* __next_next = __next->_M_next;
 __pos->_M_next = __next_next;
 get_allocator().destroy(&__next->_M_data);
 _M_put_node(__next);
 return __next_next;
      }
      _Slist_node_base* _M_erase_after(_Slist_node_base*, _Slist_node_base*);
    };

  template <class _Tp, class _Alloc>
    _Slist_node_base*
    _Slist_base<_Tp,_Alloc>::_M_erase_after(_Slist_node_base* __before_first,
         _Slist_node_base* __last_node)
    {
      _Slist_node<_Tp>* __cur = (_Slist_node<_Tp>*) (__before_first->_M_next);
      while (__cur != __last_node)
 {
   _Slist_node<_Tp>* __tmp = __cur;
   __cur = (_Slist_node<_Tp>*) __cur->_M_next;
   get_allocator().destroy(&__tmp->_M_data);
   _M_put_node(__tmp);
 }
      __before_first->_M_next = __last_node;
      return __last_node;
    }






  template <class _Tp, class _Alloc = allocator<_Tp> >
    class slist : private _Slist_base<_Tp,_Alloc>
    {

     

    private:
      typedef _Slist_base<_Tp,_Alloc> _Base;

    public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;

      typedef _Slist_iterator<_Tp, _Tp&, _Tp*> iterator;
      typedef _Slist_iterator<_Tp, const _Tp&, const _Tp*> const_iterator;

      typedef typename _Base::allocator_type allocator_type;

      allocator_type
      get_allocator() const
      { return _Base::get_allocator(); }

    private:
      typedef _Slist_node<_Tp> _Node;
      typedef _Slist_node_base _Node_base;
      typedef _Slist_iterator_base _Iterator_base;

      _Node*
      _M_create_node(const value_type& __x)
      {
 _Node* __node = this->_M_get_node();
 try
   {
     get_allocator().construct(&__node->_M_data, __x);
     __node->_M_next = 0;
   }
 catch(...)
   {
     this->_M_put_node(__node);
     throw;
   }
 return __node;
      }

      _Node*
      _M_create_node()
      {
 _Node* __node = this->_M_get_node();
 try
   {
     get_allocator().construct(&__node->_M_data, value_type());
     __node->_M_next = 0;
   }
 catch(...)
   {
     this->_M_put_node(__node);
     throw;
   }
 return __node;
      }

    public:
      explicit
      slist(const allocator_type& __a = allocator_type())
      : _Base(__a) {}

      slist(size_type __n, const value_type& __x,
     const allocator_type& __a = allocator_type())
      : _Base(__a)
      { _M_insert_after_fill(&this->_M_head, __n, __x); }

      explicit
      slist(size_type __n)
      : _Base(allocator_type())
      { _M_insert_after_fill(&this->_M_head, __n, value_type()); }



      template <class _InputIterator>
        slist(_InputIterator __first, _InputIterator __last,
       const allocator_type& __a = allocator_type())
 : _Base(__a)
        { _M_insert_after_range(&this->_M_head, __first, __last); }

      slist(const slist& __x)
      : _Base(__x.get_allocator())
      { _M_insert_after_range(&this->_M_head, __x.begin(), __x.end()); }

      slist&
      operator= (const slist& __x);

      ~slist() {}

    public:





      void
      assign(size_type __n, const _Tp& __val)
      { _M_fill_assign(__n, __val); }

      void
      _M_fill_assign(size_type __n, const _Tp& __val);

      template <class _InputIterator>
        void
        assign(_InputIterator __first, _InputIterator __last)
        {
   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
   _M_assign_dispatch(__first, __last, _Integral());
 }

      template <class _Integer>
      void
      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      { _M_fill_assign((size_type) __n, (_Tp) __val); }

      template <class _InputIterator>
      void
      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    __false_type);

    public:

      iterator
      begin()
      { return iterator((_Node*)this->_M_head._M_next); }

      const_iterator
      begin() const
      { return const_iterator((_Node*)this->_M_head._M_next);}

      iterator
      end()
      { return iterator(0); }

      const_iterator
      end() const
      { return const_iterator(0); }
# 445 "/usr/include/c++/4.8/ext/slist" 3 4
      iterator
      before_begin()
      { return iterator((_Node*) &this->_M_head); }

      const_iterator
      before_begin() const
      { return const_iterator((_Node*) &this->_M_head); }

      size_type
      size() const
      { return __slist_size(this->_M_head._M_next); }

      size_type
      max_size() const
      { return size_type(-1); }

      bool
      empty() const
      { return this->_M_head._M_next == 0; }

      void
      swap(slist& __x)
      { std::swap(this->_M_head._M_next, __x._M_head._M_next); }

    public:

      reference
      front()
      { return ((_Node*) this->_M_head._M_next)->_M_data; }

      const_reference
      front() const
      { return ((_Node*) this->_M_head._M_next)->_M_data; }

      void
      push_front(const value_type& __x)
      { __slist_make_link(&this->_M_head, _M_create_node(__x)); }

      void
      push_front()
      { __slist_make_link(&this->_M_head, _M_create_node()); }

      void
      pop_front()
      {
 _Node* __node = (_Node*) this->_M_head._M_next;
 this->_M_head._M_next = __node->_M_next;
 get_allocator().destroy(&__node->_M_data);
 this->_M_put_node(__node);
      }

      iterator
      previous(const_iterator __pos)
      { return iterator((_Node*) __slist_previous(&this->_M_head,
        __pos._M_node)); }

      const_iterator
      previous(const_iterator __pos) const
      { return const_iterator((_Node*) __slist_previous(&this->_M_head,
       __pos._M_node)); }

    private:
      _Node*
      _M_insert_after(_Node_base* __pos, const value_type& __x)
      { return (_Node*) (__slist_make_link(__pos, _M_create_node(__x))); }

      _Node*
      _M_insert_after(_Node_base* __pos)
      { return (_Node*) (__slist_make_link(__pos, _M_create_node())); }

      void
      _M_insert_after_fill(_Node_base* __pos,
      size_type __n, const value_type& __x)
      {
 for (size_type __i = 0; __i < __n; ++__i)
   __pos = __slist_make_link(__pos, _M_create_node(__x));
      }


      template <class _InIterator>
        void
        _M_insert_after_range(_Node_base* __pos,
         _InIterator __first, _InIterator __last)
        {
   typedef typename std::__is_integer<_InIterator>::__type _Integral;
   _M_insert_after_range(__pos, __first, __last, _Integral());
 }

      template <class _Integer>
        void
        _M_insert_after_range(_Node_base* __pos, _Integer __n, _Integer __x,
         __true_type)
        { _M_insert_after_fill(__pos, __n, __x); }

      template <class _InIterator>
        void
        _M_insert_after_range(_Node_base* __pos,
         _InIterator __first, _InIterator __last,
         __false_type)
        {
   while (__first != __last)
     {
       __pos = __slist_make_link(__pos, _M_create_node(*__first));
       ++__first;
     }
 }

    public:
      iterator
      insert_after(iterator __pos, const value_type& __x)
      { return iterator(_M_insert_after(__pos._M_node, __x)); }

      iterator
      insert_after(iterator __pos)
      { return insert_after(__pos, value_type()); }

      void
      insert_after(iterator __pos, size_type __n, const value_type& __x)
      { _M_insert_after_fill(__pos._M_node, __n, __x); }



      template <class _InIterator>
        void
        insert_after(iterator __pos, _InIterator __first, _InIterator __last)
        { _M_insert_after_range(__pos._M_node, __first, __last); }

      iterator
      insert(iterator __pos, const value_type& __x)
      { return iterator(_M_insert_after(__slist_previous(&this->_M_head,
        __pos._M_node),
     __x)); }

      iterator
      insert(iterator __pos)
      { return iterator(_M_insert_after(__slist_previous(&this->_M_head,
        __pos._M_node),
     value_type())); }

      void
      insert(iterator __pos, size_type __n, const value_type& __x)
      { _M_insert_after_fill(__slist_previous(&this->_M_head, __pos._M_node),
        __n, __x); }



      template <class _InIterator>
        void
        insert(iterator __pos, _InIterator __first, _InIterator __last)
        { _M_insert_after_range(__slist_previous(&this->_M_head, __pos._M_node),
    __first, __last); }

    public:
      iterator
      erase_after(iterator __pos)
      { return iterator((_Node*) this->_M_erase_after(__pos._M_node)); }

      iterator
      erase_after(iterator __before_first, iterator __last)
      {
 return iterator((_Node*) this->_M_erase_after(__before_first._M_node,
            __last._M_node));
      }

      iterator
      erase(iterator __pos)
      {
 return iterator((_Node*) this->_M_erase_after
   (__slist_previous(&this->_M_head, __pos._M_node)));
      }

      iterator
      erase(iterator __first, iterator __last)
      {
 return iterator((_Node*) this->_M_erase_after
   (__slist_previous(&this->_M_head, __first._M_node),
    __last._M_node));
      }

      void
      resize(size_type new_size, const _Tp& __x);

      void
      resize(size_type new_size)
      { resize(new_size, _Tp()); }

      void
      clear()
      { this->_M_erase_after(&this->_M_head, 0); }

    public:


      void
      splice_after(iterator __pos,
     iterator __before_first, iterator __before_last)
      {
 if (__before_first != __before_last)
   __slist_splice_after(__pos._M_node, __before_first._M_node,
          __before_last._M_node);
      }



      void
      splice_after(iterator __pos, iterator __prev)
      { __slist_splice_after(__pos._M_node,
        __prev._M_node, __prev._M_node->_M_next); }




      void
      splice_after(iterator __pos, slist& __x)
      { __slist_splice_after(__pos._M_node, &__x._M_head); }


      void
      splice(iterator __pos, slist& __x)
      {
 if (__x._M_head._M_next)
   __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
          &__x._M_head,
          __slist_previous(&__x._M_head, 0)); }


      void
      splice(iterator __pos, slist& __x, iterator __i)
      { __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
        __slist_previous(&__x._M_head, __i._M_node),
        __i._M_node); }



      void
      splice(iterator __pos, slist& __x, iterator __first, iterator __last)
      {
 if (__first != __last)
   __slist_splice_after(__slist_previous(&this->_M_head, __pos._M_node),
          __slist_previous(&__x._M_head, __first._M_node),
          __slist_previous(__first._M_node,
      __last._M_node));
      }

    public:
      void
      reverse()
      {
 if (this->_M_head._M_next)
   this->_M_head._M_next = __slist_reverse(this->_M_head._M_next);
      }

      void
      remove(const _Tp& __val);

      void
      unique();

      void
      merge(slist& __x);

      void
      sort();

      template <class _Predicate>
        void
        remove_if(_Predicate __pred);

      template <class _BinaryPredicate>
        void
        unique(_BinaryPredicate __pred);

      template <class _StrictWeakOrdering>
        void
        merge(slist&, _StrictWeakOrdering);

      template <class _StrictWeakOrdering>
        void
        sort(_StrictWeakOrdering __comp);
    };

  template <class _Tp, class _Alloc>
    slist<_Tp, _Alloc>&
    slist<_Tp, _Alloc>::operator=(const slist<_Tp, _Alloc>& __x)
    {
      if (&__x != this)
 {
   _Node_base* __p1 = &this->_M_head;
   _Node* __n1 = (_Node*) this->_M_head._M_next;
   const _Node* __n2 = (const _Node*) __x._M_head._M_next;
   while (__n1 && __n2)
     {
       __n1->_M_data = __n2->_M_data;
       __p1 = __n1;
       __n1 = (_Node*) __n1->_M_next;
       __n2 = (const _Node*) __n2->_M_next;
     }
   if (__n2 == 0)
     this->_M_erase_after(__p1, 0);
   else
     _M_insert_after_range(__p1, const_iterator((_Node*)__n2),
                                  const_iterator(0));
 }
      return *this;
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::_M_fill_assign(size_type __n, const _Tp& __val)
    {
      _Node_base* __prev = &this->_M_head;
      _Node* __node = (_Node*) this->_M_head._M_next;
      for (; __node != 0 && __n > 0; --__n)
 {
   __node->_M_data = __val;
   __prev = __node;
   __node = (_Node*) __node->_M_next;
 }
      if (__n > 0)
 _M_insert_after_fill(__prev, __n, __val);
      else
 this->_M_erase_after(__prev, 0);
    }

  template <class _Tp, class _Alloc>
    template <class _InputIterator>
      void
      slist<_Tp, _Alloc>::_M_assign_dispatch(_InputIterator __first,
          _InputIterator __last,
          __false_type)
      {
 _Node_base* __prev = &this->_M_head;
 _Node* __node = (_Node*) this->_M_head._M_next;
 while (__node != 0 && __first != __last)
   {
     __node->_M_data = *__first;
     __prev = __node;
     __node = (_Node*) __node->_M_next;
     ++__first;
   }
 if (__first != __last)
   _M_insert_after_range(__prev, __first, __last);
 else
   this->_M_erase_after(__prev, 0);
      }

  template <class _Tp, class _Alloc>
    inline bool
    operator==(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    {
      typedef typename slist<_Tp,_Alloc>::const_iterator const_iterator;
      const_iterator __end1 = _SL1.end();
      const_iterator __end2 = _SL2.end();

      const_iterator __i1 = _SL1.begin();
      const_iterator __i2 = _SL2.begin();
      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
 {
   ++__i1;
   ++__i2;
 }
      return __i1 == __end1 && __i2 == __end2;
    }


  template <class _Tp, class _Alloc>
    inline bool
    operator<(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return std::lexicographical_compare(_SL1.begin(), _SL1.end(),
       _SL2.begin(), _SL2.end()); }

  template <class _Tp, class _Alloc>
    inline bool
    operator!=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return !(_SL1 == _SL2); }

  template <class _Tp, class _Alloc>
    inline bool
    operator>(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return _SL2 < _SL1; }

  template <class _Tp, class _Alloc>
    inline bool
    operator<=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return !(_SL2 < _SL1); }

  template <class _Tp, class _Alloc>
    inline bool
    operator>=(const slist<_Tp, _Alloc>& _SL1, const slist<_Tp, _Alloc>& _SL2)
    { return !(_SL1 < _SL2); }

  template <class _Tp, class _Alloc>
    inline void
    swap(slist<_Tp, _Alloc>& __x, slist<_Tp, _Alloc>& __y)
    { __x.swap(__y); }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::resize(size_type __len, const _Tp& __x)
    {
      _Node_base* __cur = &this->_M_head;
      while (__cur->_M_next != 0 && __len > 0)
 {
   --__len;
   __cur = __cur->_M_next;
 }
      if (__cur->_M_next)
 this->_M_erase_after(__cur, 0);
      else
 _M_insert_after_fill(__cur, __len, __x);
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::remove(const _Tp& __val)
    {
      _Node_base* __cur = &this->_M_head;
      while (__cur && __cur->_M_next)
 {
   if (((_Node*) __cur->_M_next)->_M_data == __val)
     this->_M_erase_after(__cur);
   else
     __cur = __cur->_M_next;
 }
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::unique()
    {
      _Node_base* __cur = this->_M_head._M_next;
      if (__cur)
 {
   while (__cur->_M_next)
     {
       if (((_Node*)__cur)->_M_data
    == ((_Node*)(__cur->_M_next))->_M_data)
  this->_M_erase_after(__cur);
       else
  __cur = __cur->_M_next;
     }
 }
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::merge(slist<_Tp, _Alloc>& __x)
    {
      _Node_base* __n1 = &this->_M_head;
      while (__n1->_M_next && __x._M_head._M_next)
 {
   if (((_Node*) __x._M_head._M_next)->_M_data
       < ((_Node*) __n1->_M_next)->_M_data)
     __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
   __n1 = __n1->_M_next;
 }
      if (__x._M_head._M_next)
 {
   __n1->_M_next = __x._M_head._M_next;
   __x._M_head._M_next = 0;
 }
    }

  template <class _Tp, class _Alloc>
    void
    slist<_Tp, _Alloc>::sort()
    {
      if (this->_M_head._M_next && this->_M_head._M_next->_M_next)
 {
   slist __carry;
   slist __counter[64];
   int __fill = 0;
   while (!empty())
     {
       __slist_splice_after(&__carry._M_head,
       &this->_M_head, this->_M_head._M_next);
       int __i = 0;
       while (__i < __fill && !__counter[__i].empty())
  {
    __counter[__i].merge(__carry);
    __carry.swap(__counter[__i]);
    ++__i;
  }
       __carry.swap(__counter[__i]);
       if (__i == __fill)
  ++__fill;
     }

   for (int __i = 1; __i < __fill; ++__i)
     __counter[__i].merge(__counter[__i-1]);
   this->swap(__counter[__fill-1]);
 }
    }

  template <class _Tp, class _Alloc>
    template <class _Predicate>
      void slist<_Tp, _Alloc>::remove_if(_Predicate __pred)
      {
 _Node_base* __cur = &this->_M_head;
 while (__cur->_M_next)
   {
     if (__pred(((_Node*) __cur->_M_next)->_M_data))
       this->_M_erase_after(__cur);
     else
       __cur = __cur->_M_next;
   }
      }

  template <class _Tp, class _Alloc>
    template <class _BinaryPredicate>
      void
      slist<_Tp, _Alloc>::unique(_BinaryPredicate __pred)
      {
 _Node* __cur = (_Node*) this->_M_head._M_next;
 if (__cur)
   {
     while (__cur->_M_next)
       {
  if (__pred(((_Node*)__cur)->_M_data,
      ((_Node*)(__cur->_M_next))->_M_data))
    this->_M_erase_after(__cur);
  else
    __cur = (_Node*) __cur->_M_next;
       }
   }
      }

  template <class _Tp, class _Alloc>
    template <class _StrictWeakOrdering>
      void
      slist<_Tp, _Alloc>::merge(slist<_Tp, _Alloc>& __x,
          _StrictWeakOrdering __comp)
      {
 _Node_base* __n1 = &this->_M_head;
 while (__n1->_M_next && __x._M_head._M_next)
   {
     if (__comp(((_Node*) __x._M_head._M_next)->_M_data,
         ((_Node*) __n1->_M_next)->_M_data))
       __slist_splice_after(__n1, &__x._M_head, __x._M_head._M_next);
     __n1 = __n1->_M_next;
   }
 if (__x._M_head._M_next)
   {
     __n1->_M_next = __x._M_head._M_next;
     __x._M_head._M_next = 0;
   }
      }

  template <class _Tp, class _Alloc>
    template <class _StrictWeakOrdering>
      void
      slist<_Tp, _Alloc>::sort(_StrictWeakOrdering __comp)
      {
 if (this->_M_head._M_next && this->_M_head._M_next->_M_next)
   {
     slist __carry;
     slist __counter[64];
     int __fill = 0;
     while (!empty())
       {
  __slist_splice_after(&__carry._M_head,
         &this->_M_head, this->_M_head._M_next);
  int __i = 0;
  while (__i < __fill && !__counter[__i].empty())
    {
      __counter[__i].merge(__carry, __comp);
      __carry.swap(__counter[__i]);
      ++__i;
    }
  __carry.swap(__counter[__i]);
  if (__i == __fill)
    ++__fill;
       }

     for (int __i = 1; __i < __fill; ++__i)
       __counter[__i].merge(__counter[__i-1], __comp);
     this->swap(__counter[__fill-1]);
   }
      }


}

namespace std __attribute__ ((__visibility__ ("default")))
{




  template <class _Tp, class _Alloc>
    class insert_iterator<__gnu_cxx::slist<_Tp, _Alloc> >
    {
    protected:
      typedef __gnu_cxx::slist<_Tp, _Alloc> _Container;
      _Container* container;
      typename _Container::iterator iter;

    public:
      typedef _Container container_type;
      typedef output_iterator_tag iterator_category;
      typedef void value_type;
      typedef void difference_type;
      typedef void pointer;
      typedef void reference;

      insert_iterator(_Container& __x, typename _Container::iterator __i)
      : container(&__x)
      {
 if (__i == __x.begin())
   iter = __x.before_begin();
 else
   iter = __x.previous(__i);
      }

      insert_iterator<_Container>&
      operator=(const typename _Container::value_type& __value)
      {
 iter = container->insert_after(iter, __value);
 return *this;
      }

      insert_iterator<_Container>&
      operator*()
      { return *this; }

      insert_iterator<_Container>&
      operator++()
      { return *this; }

      insert_iterator<_Container>&
      operator++(int)
      { return *this; }
    };


}
# 17 "/usr/include/boost/algorithm/string/std/slist_traits.hpp" 2 3 4


namespace boost {
    namespace algorithm {
# 41 "/usr/include/boost/algorithm/string/std/slist_traits.hpp" 3 4
        template<typename T, typename AllocT>
        class has_stable_iterators< __gnu_cxx::slist<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_stable_iterators<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_insert< __gnu_cxx::slist<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_insert<T>::value> type;
        };


        template<typename T, typename AllocT>
        class has_const_time_erase< __gnu_cxx::slist<T,AllocT> >
        {
        public:



            static const bool value=true;

            typedef mpl::bool_<has_const_time_erase<T>::value> type;
        };



    }
}
# 24 "/usr/include/boost/algorithm/string/std_containers_traits.hpp" 2 3 4
# 19 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/trim.hpp" 1 3 4
# 16 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
# 1 "/usr/include/boost/range/begin.hpp" 1 3 4
# 18 "/usr/include/boost/range/begin.hpp" 3 4
# 1 "/usr/include/boost/range/config.hpp" 1 3 4
# 19 "/usr/include/boost/range/begin.hpp" 2 3 4





# 1 "/usr/include/boost/range/iterator.hpp" 1 3 4
# 19 "/usr/include/boost/range/iterator.hpp" 3 4
# 1 "/usr/include/boost/range/mutable_iterator.hpp" 1 3 4
# 24 "/usr/include/boost/range/mutable_iterator.hpp" 3 4
# 1 "/usr/include/boost/range/detail/extract_optional_type.hpp" 1 3 4
# 30 "/usr/include/boost/range/detail/extract_optional_type.hpp" 3 4
namespace boost {
    namespace range_detail {
        template< typename T > struct exists { typedef void type; };
    }
}
# 25 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_traits.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
namespace boost {
# 27 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
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;
};
# 90 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
}
# 26 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 27 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4


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;
    };

}
# 20 "/usr/include/boost/range/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/range/const_iterator.hpp" 1 3 4
# 26 "/usr/include/boost/range/const_iterator.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 27 "/usr/include/boost/range/const_iterator.hpp" 2 3 4


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;
    };

}
# 21 "/usr/include/boost/range/iterator.hpp" 2 3 4




namespace boost
{
# 50 "/usr/include/boost/range/iterator.hpp" 3 4
    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;


    };

}
# 25 "/usr/include/boost/range/begin.hpp" 2 3 4

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;
    }
# 75 "/usr/include/boost/range/begin.hpp" 3 4
    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;
}
# 17 "/usr/include/boost/algorithm/string/trim.hpp" 2 3 4
# 1 "/usr/include/boost/range/end.hpp" 1 3 4
# 24 "/usr/include/boost/range/end.hpp" 3 4
# 1 "/usr/include/boost/range/detail/implementation_help.hpp" 1 3 4
# 15 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
# 1 "/usr/include/boost/range/detail/common.hpp" 1 3 4
# 19 "/usr/include/boost/range/detail/common.hpp" 3 4
# 1 "/usr/include/boost/range/detail/sfinae.hpp" 1 3 4
# 20 "/usr/include/boost/range/detail/sfinae.hpp" 3 4
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 {};

    }

}
# 20 "/usr/include/boost/range/detail/common.hpp" 2 3 4




# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 25 "/usr/include/boost/range/detail/common.hpp" 2 3 4





namespace boost
{
    namespace range_detail
    {
# 47 "/usr/include/boost/range/detail/common.hpp" 3 4
        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;
        };
    }
}
# 16 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 18 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4



# 1 "/usr/include/wchar.h" 1 3 4
# 22 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4


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 );
        }
# 56 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
        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;
        }

    }

}
# 25 "/usr/include/boost/range/end.hpp" 2 3 4



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;
}
# 18 "/usr/include/boost/algorithm/string/trim.hpp" 2 3 4

# 1 "/usr/include/boost/range/as_literal.hpp" 1 3 4
# 22 "/usr/include/boost/range/as_literal.hpp" 3 4
# 1 "/usr/include/boost/range/iterator_range.hpp" 1 3 4
# 13 "/usr/include/boost/range/iterator_range.hpp" 3 4
# 1 "/usr/include/boost/range/iterator_range_core.hpp" 1 3 4
# 21 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 22 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4

# 1 "/usr/include/boost/iterator/iterator_facade.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
# 1 "/usr/include/boost/iterator/interoperable.hpp" 1 3 4
# 15 "/usr/include/boost/iterator/interoperable.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 16 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4

namespace boost
{
# 34 "/usr/include/boost/iterator/interoperable.hpp" 3 4
  template <typename A, typename B>
  struct is_interoperable



    : mpl::or_<
          is_convertible< A, B >
        , is_convertible< B, A > >

  {
  };

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 49 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
# 12 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 1 3 4
# 23 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 24 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4


# 1 "/usr/include/boost/detail/indirect_traits.hpp" 1 3 4
# 17 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
# 1 "/usr/include/boost/type_traits/remove_pointer.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/remove_pointer.hpp" 2 3 4

namespace boost {
# 76 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
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; };







}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 91 "/usr/include/boost/type_traits/remove_pointer.hpp" 2 3 4
# 18 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
# 33 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
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_
{
};
# 55 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
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_
{
};
# 149 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
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
          >
      >
{
   
};
# 481 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
}

using namespace indirect_traits;

}}
# 27 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4







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>
    >



{};
# 86 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
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>
    >
{
};

}}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 199 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
# 15 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/detail/enable_if.hpp" 1 3 4
# 13 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 14 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4







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
      {
# 62 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
      };
    };


    template <class Cond,
              class Return>
    struct enable_if

      : enabled<(Cond::value)>::template base<Return>



    {



    };

  }

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 85 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
# 16 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 33 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
# 1 "/usr/include/boost/mpl/always.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/always.hpp" 3 4
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;
    };
};



}}
# 34 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_fwd.hpp" 1 3 4
# 31 "/usr/include/boost/mpl/apply_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 3 4
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;

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/apply_fwd.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_apply.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/has_apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/has_xxx.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 3 4
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;
};







}}}
# 22 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/has_apply.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4

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; };







}}}
# 24 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/msvc_never_true.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 34 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 3 4
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 >
{
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/lambda.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/bind.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/bind_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/bind.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4






# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 3 4
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;

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/next.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/next.hpp" 3 4
# 1 "/usr/include/boost/mpl/next_prior.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/next_prior.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/common_name_wknd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/next_prior.hpp" 2 3 4



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> { }; }

}}
# 18 "/usr/include/boost/mpl/next.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/protect.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/protect.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename T = na
    , int not_le_ = 0
    >
struct protect : T
{



    typedef protect type;

};
# 48 "/usr/include/boost/mpl/protect.hpp" 3 4
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> { }; }


}}
# 27 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 50 "/usr/include/boost/mpl/bind.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 3 4
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;
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 51 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/lambda.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/quote.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/quote.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_type.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_type.hpp" 3 4
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; };
}}}
# 24 "/usr/include/boost/mpl/quote.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/bcc.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/quote.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 3 4
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
            >

    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
# 43 "/usr/include/boost/mpl/aux_/template_arity.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 3 4
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;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/aux_/template_arity.hpp" 2 3 4
# 30 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 3 4
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> { }; }

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 3 4
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 >
{
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 35 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 38 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4

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
# 80 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
      : ::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;
# 131 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    };







    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;
    };
# 245 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
            typename remove_reference<Reference>::type
            const volatile*
          , Value const volatile*
        >
    {};
# 270 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    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 Reference, class Pointer>
    struct operator_arrow_dispatch
    {
        struct proxy
        {
            explicit proxy(Reference const & x) : m_ref(x) {}
            Reference* operator->() { return boost::addressof(m_ref); }


            operator Reference*() { return boost::addressof(m_ref); }
            Reference m_ref;
        };
        typedef proxy result_type;
        static result_type apply(Reference const & x)
        {
            return result_type(x);
        }
    };

    template <class T, class Pointer>
    struct operator_arrow_dispatch<T&, Pointer>
    {
        typedef Pointer result_type;
        static result_type apply(T& x)
        {
            return boost::addressof(x);
        }
    };
# 340 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    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
          :
# 418 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >

        {};

    };
  }
# 469 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  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_dispatch<
          Reference
        , typename associated_types::pointer
      > operator_arrow_dispatch_;

   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 operator_arrow_dispatch_::result_type pointer;

      typedef typename associated_types::iterator_category iterator_category;

      reference operator*() const
      {
          return iterator_core_access::dereference(this->derived());
      }

      pointer operator->() const
      {
          return operator_arrow_dispatch_::apply(*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();
      }
# 675 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
      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;
      }
# 717 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  };


  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;
  }
# 832 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  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_832; 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_833; 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_835; 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_836; 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_837; 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_838; 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_847; return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
# 858 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
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; }






}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 873 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 24 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4


# 1 "/usr/include/boost/range/functions.hpp" 1 3 4
# 20 "/usr/include/boost/range/functions.hpp" 3 4
# 1 "/usr/include/boost/range/size.hpp" 1 3 4
# 21 "/usr/include/boost/range/size.hpp" 3 4
# 1 "/usr/include/boost/range/size_type.hpp" 1 3 4
# 19 "/usr/include/boost/range/size_type.hpp" 3 4
# 1 "/usr/include/boost/range/difference_type.hpp" 1 3 4
# 22 "/usr/include/boost/range/difference_type.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_difference : iterator_difference< typename range_iterator<T>::type >
    { };
}
# 20 "/usr/include/boost/range/size_type.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/make_unsigned.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_signed.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4

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;

};
# 126 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
}






template< typename T > struct is_signed : public ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { public: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 139 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
# 29 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 30 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4

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,
# 82 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
                     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,
# 114 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
                     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; };

}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 151 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
# 26 "/usr/include/boost/range/size_type.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 28 "/usr/include/boost/range/size_type.hpp" 2 3 4


namespace boost
{
    namespace detail
    {





        template<typename T>
        class has_size_type
        {
            typedef char no_type;
            struct yes_type { char dummy[2]; };

            template<typename C>
            static yes_type test(typename C::size_type x);

            template<typename C, typename Arg>
            static no_type test(Arg x);

        public:
            static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
        };

        template<typename C, typename Enabler=void>
        struct range_size
        {
            typedef typename make_unsigned<
                typename range_difference<C>::type
            >::type type;
        };

        template<typename C>
        struct range_size<
            C,
            typename enable_if<has_size_type<C>, void>::type
        >
        {
            typedef typename C::size_type type;
        };

    }

    template< class T >
    struct range_size :
        detail::range_size<T>
    { };

    template< class T >
    struct range_size<const T >
        : detail::range_size<T>
    { };

}
# 22 "/usr/include/boost/range/size.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 23 "/usr/include/boost/range/size.hpp" 2 3 4

namespace boost
{
    namespace range_detail
    {
        template<class SinglePassRange>
        inline typename range_size<const SinglePassRange>::type
        range_calculate_size(const SinglePassRange& rng)
        {
            (((boost::end(rng) - boost::begin(rng)) >= 0 && "reachability invariant broken!") ? static_cast<void> (0) : __assert_fail ("(boost::end(rng) - boost::begin(rng)) >= 0 && \"reachability invariant broken!\"",
 "/usr/include/boost/range/size.hpp"
# 32 "/usr/include/boost/range/size.hpp" 3 4
            ,
 33
# 32 "/usr/include/boost/range/size.hpp" 3 4
            , __PRETTY_FUNCTION__))
                                                            ;
            return boost::end(rng) - boost::begin(rng);
        }
    }

    template<class SinglePassRange>
    inline typename range_size<const SinglePassRange>::type
    size(const SinglePassRange& rng)
    {



        using namespace range_detail;

        return range_calculate_size(rng);
    }

}
# 21 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/distance.hpp" 1 3 4
# 22 "/usr/include/boost/range/distance.hpp" 3 4
namespace boost
{

    template< class T >
    inline typename range_difference<T>::type
    distance( const T& r )
    {
        return std::distance( boost::begin( r ), boost::end( r ) );
    }

}
# 22 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/empty.hpp" 1 3 4
# 22 "/usr/include/boost/range/empty.hpp" 3 4
namespace boost
{

    template< class T >
    inline bool empty( const T& r )
    {
        return boost::begin( r ) == boost::end( r );
    }

}
# 23 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/rbegin.hpp" 1 3 4
# 19 "/usr/include/boost/range/rbegin.hpp" 3 4
# 1 "/usr/include/boost/range/reverse_iterator.hpp" 1 3 4
# 20 "/usr/include/boost/range/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/iterator/reverse_iterator.hpp" 1 3 4
# 10 "/usr/include/boost/iterator/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/next_prior.hpp" 1 3 4
# 17 "/usr/include/boost/next_prior.hpp" 3 4
namespace boost {
# 29 "/usr/include/boost/next_prior.hpp" 3 4
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;
}

}
# 11 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4

# 1 "/usr/include/boost/iterator/iterator_adaptor.hpp" 1 3 4
# 30 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 31 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4



namespace boost
{



  struct use_default;





  template<class To>
  struct is_convertible<use_default,To>
    : mpl::false_ {};


  namespace detail
  {
# 60 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
    struct enable_type;
  }
# 142 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
  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;
    }
  }
# 253 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
  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;
  };

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 364 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
# 13 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4

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);
  }

}
# 21 "/usr/include/boost/range/reverse_iterator.hpp" 2 3 4


namespace boost
{




    template< typename C >
    struct range_reverse_iterator
    {
        typedef reverse_iterator<
            typename range_iterator<C>::type > type;
    };


}
# 20 "/usr/include/boost/range/rbegin.hpp" 2 3 4

namespace boost
{
# 35 "/usr/include/boost/range/rbegin.hpp" 3 4
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 );
}

}
# 24 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/rend.hpp" 1 3 4
# 21 "/usr/include/boost/range/rend.hpp" 3 4
namespace boost
{
# 35 "/usr/include/boost/range/rend.hpp" 3 4
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 );
}

}
# 25 "/usr/include/boost/range/functions.hpp" 2 3 4
# 27 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4


# 1 "/usr/include/boost/range/algorithm/equal.hpp" 1 3 4
# 14 "/usr/include/boost/range/algorithm/equal.hpp" 3 4
# 1 "/usr/include/boost/range/concepts.hpp" 1 3 4
# 19 "/usr/include/boost/range/concepts.hpp" 3 4
# 1 "/usr/include/boost/concept_check.hpp" 1 3 4
# 20 "/usr/include/boost/concept_check.hpp" 3 4
# 1 "/usr/include/boost/concept/assert.hpp" 1 3 4
# 36 "/usr/include/boost/concept/assert.hpp" 3 4
# 1 "/usr/include/boost/concept/detail/general.hpp" 1 3 4







# 1 "/usr/include/boost/concept/detail/backward_compatibility.hpp" 1 3 4






namespace boost
{
  namespace concepts {}




}
# 9 "/usr/include/boost/concept/detail/general.hpp" 2 3 4


# 1 "/usr/include/boost/concept/detail/has_constraints.hpp" 1 3 4
# 11 "/usr/include/boost/concept/detail/has_constraints.hpp" 3 4
namespace boost { namespace concepts {

namespace detail
{



  typedef char yes;
  typedef char (&no)[2];

  template <class Model, void (Model::*)()>
  struct wrap_constraints {};
# 31 "/usr/include/boost/concept/detail/has_constraints.hpp" 3 4
  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;
};

}}
# 12 "/usr/include/boost/concept/detail/general.hpp" 2 3 4





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
{};
# 73 "/usr/include/boost/concept/detail/general.hpp" 3 4
}}
# 37 "/usr/include/boost/concept/assert.hpp" 2 3 4
# 21 "/usr/include/boost/concept_check.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/conversion_traits.hpp" 1 3 4
# 24 "/usr/include/boost/concept_check.hpp" 2 3 4
# 32 "/usr/include/boost/concept_check.hpp" 3 4
# 1 "/usr/include/boost/concept/usage.hpp" 1 3 4
# 11 "/usr/include/boost/concept/usage.hpp" 3 4
namespace boost { namespace concepts {







template <class Model>
struct usage_requirements
{
    ~usage_requirements() { ((Model*)0)->~Model(); }
};
# 42 "/usr/include/boost/concept/usage.hpp" 3 4
}}
# 33 "/usr/include/boost/concept_check.hpp" 2 3 4
# 1 "/usr/include/boost/concept/detail/concept_def.hpp" 1 3 4





# 1 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/seq.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/seq/seq.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/elem.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/seq/seq.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
# 7 "/usr/include/boost/concept/detail/concept_def.hpp" 2 3 4
# 34 "/usr/include/boost/concept_check.hpp" 2 3 4

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&) {}
# 65 "/usr/include/boost/concept_check.hpp" 3 4
  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;
  };
# 228 "/usr/include/boost/concept_check.hpp" 3 4
  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;
  };
# 286 "/usr/include/boost/concept_check.hpp" 3 4
  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& cc) {
        ci = cc.begin();
        ci = cc.end();
        n = cc.size();
        b = cc.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;
  };
}

# 1 "/usr/include/boost/concept/detail/concept_undef.hpp" 1 3 4
# 1081 "/usr/include/boost/concept_check.hpp" 2 3 4
# 20 "/usr/include/boost/range/concepts.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_concepts.hpp" 1 3 4
# 31 "/usr/include/boost/iterator/iterator_concepts.hpp" 3 4
# 1 "/usr/include/boost/concept/detail/concept_def.hpp" 1 3 4
# 32 "/usr/include/boost/iterator/iterator_concepts.hpp" 2 3 4

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;
  };

}

# 1 "/usr/include/boost/concept/detail/concept_undef.hpp" 1 3 4
# 283 "/usr/include/boost/iterator/iterator_concepts.hpp" 2 3 4
# 21 "/usr/include/boost/range/concepts.hpp" 2 3 4



# 1 "/usr/include/boost/range/value_type.hpp" 1 3 4
# 27 "/usr/include/boost/range/value_type.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_value : iterator_value< typename range_iterator<T>::type >
    { };
}
# 25 "/usr/include/boost/range/concepts.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/misc_concept.hpp" 1 3 4
# 13 "/usr/include/boost/range/detail/misc_concept.hpp" 3 4
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;
        };
    }
}
# 26 "/usr/include/boost/range/concepts.hpp" 2 3 4
# 59 "/usr/include/boost/range/concepts.hpp" 3 4
namespace boost {

    namespace range_detail {
# 112 "/usr/include/boost/range/concepts.hpp" 3 4
        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>
    {
    };

}
# 15 "/usr/include/boost/range/algorithm/equal.hpp" 2 3 4


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 )
        {
            while (true)
            {



                if (first1 == last1)
                    return first2 == last2;




                if (first2 == last2)
                    return false;


                if (*first1 != *first2)
                    break;

                ++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 )
        {
            while (true)
            {



                if (first1 == last1)
                    return first2 == last2;




                if (first2 == last2)
                    return false;


                if (!pred(*first1, *first2))
                    break;

                ++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
    {
# 169 "/usr/include/boost/range/algorithm/equal.hpp" 3 4
        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_check172;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check173;

            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_check185;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check186;

            return ::boost::range_detail::equal(
                ::boost::begin(rng1), ::boost::end(rng1),
                ::boost::begin(rng2), ::boost::end(rng2),
                pred);
        }

    }
    using ::boost::range::equal;
}
# 30 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/safe_bool.hpp" 1 3 4
# 16 "/usr/include/boost/range/detail/safe_bool.hpp" 3 4
namespace boost
{
    namespace range_detail
    {

template<class DataMemberPtr>
class safe_bool
{
public:
    typedef safe_bool this_type;
# 56 "/usr/include/boost/range/detail/safe_bool.hpp" 3 4
    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();
};

    }
}
# 31 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 35 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
# 43 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
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 { };
    }
# 124 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        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;
            }
# 310 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        public:
           reference front() const
           {
               ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/range/iterator_range_core.hpp", 313, __PRETTY_FUNCTION__));
               return *m_Begin;
           }

           reference back() const
           {
               ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/range/iterator_range_core.hpp", 319, __PRETTY_FUNCTION__));
               IteratorT last( m_End );
               return *--last;
           }


           void pop_front()
           {
               ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/range/iterator_range_core.hpp", 327, __PRETTY_FUNCTION__));
               ++m_Begin;
           }


           void pop_back()
           {
               ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/range/iterator_range_core.hpp", 334, __PRETTY_FUNCTION__));
               --m_End;
           }

           reference operator[]( difference_type at ) const
           {
               ((at >= 0 && at < size()) ? static_cast<void> (0) : __assert_fail ("at >= 0 && at < size()", "/usr/include/boost/range/iterator_range_core.hpp", 340, __PRETTY_FUNCTION__));
               return m_Begin[at];
           }






           abstract_value_type operator()( difference_type at ) const
           {
               ((at >= 0 && at < size()) ? static_cast<void> (0) : __assert_fail ("at >= 0 && at < size()", "/usr/include/boost/range/iterator_range_core.hpp", 351, __PRETTY_FUNCTION__));
               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 );
        }
# 528 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        template< typename IteratorT >
        inline iterator_range< IteratorT >
        make_iterator_range( IteratorT Begin, IteratorT End )
        {
            return iterator_range<IteratorT>( Begin, End );
        }
# 551 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        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 );
            }
        }
# 607 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        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 );
        }
# 637 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        template< typename SeqT, typename Range >
        inline SeqT copy_range( const Range& r )
        {
            return SeqT( boost::begin( r ), boost::end( r ) );
        }

}
# 14 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
# 1 "/usr/include/boost/range/iterator_range_io.hpp" 1 3 4
# 41 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 42 "/usr/include/boost/range/iterator_range_io.hpp" 2 3 4

namespace boost
{
# 54 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
        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;
        }
# 85 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
}
# 15 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
# 23 "/usr/include/boost/range/as_literal.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/str_types.hpp" 1 3 4
# 17 "/usr/include/boost/range/detail/str_types.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_mutable_iterator<T*>
    {
        typedef T* type;
    };

    template< class T >
    struct range_const_iterator<T*>
    {
        typedef const T* type;
    };

    template< class T >
    struct range_size<T*>
    {
       typedef std::size_t type;
    };
}
# 24 "/usr/include/boost/range/as_literal.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 28 "/usr/include/boost/range/as_literal.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cwchar" 1 3 4
# 39 "/usr/include/c++/4.8/cwchar" 3 4
       
# 40 "/usr/include/c++/4.8/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/usr/include/c++/4.8/cwchar" 2 3
# 30 "/usr/include/boost/range/as_literal.hpp" 2 3 4


namespace boost
{
    namespace range_detail
    {
        inline std::size_t length( const char* s )
        {
            return strlen( s );
        }


        inline std::size_t length( const wchar_t* s )
        {
            return wcslen( s );
        }
# 54 "/usr/include/boost/range/as_literal.hpp" 3 4
        inline bool is_char_ptr( char* )
        {
            return true;
        }

        inline bool is_char_ptr( const char* )
        {
            return true;
        }


        inline bool is_char_ptr( wchar_t* )
        {
            return true;
        }

        inline bool is_char_ptr( const wchar_t* )
        {
            return true;
        }


        template< class T >
        inline long is_char_ptr( const T& )
        {
            return 0L;
        }

        template< class T >
        inline iterator_range<T*>
        make_range( T* const r, bool )
        {
            return iterator_range<T*>( r, r + length(r) );
        }

        template< class T >
        inline iterator_range<typename range_iterator<T>::type>
        make_range( T& r, long )
        {
            return boost::make_iterator_range( r );
        }

    }

    template< class Range >
    inline iterator_range<typename range_iterator<Range>::type>
    as_literal( Range& r )
    {
        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
    }

    template< class Range >
    inline iterator_range<typename range_iterator<const Range>::type>
    as_literal( const Range& r )
    {
        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
    }

    template< class Char, std::size_t sz >
    inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
    {
        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
    }

    template< class Char, std::size_t sz >
    inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
    {
        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
    }
}
# 20 "/usr/include/boost/algorithm/string/trim.hpp" 2 3 4


# 1 "/usr/include/boost/algorithm/string/detail/trim.hpp" 1 3 4
# 17 "/usr/include/boost/algorithm/string/detail/trim.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_end_iter_select(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace,
                std::forward_iterator_tag )
            {
                ForwardIteratorT TrimIt=InBegin;

                for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
                {
                    if ( !IsSpace(*It) )
                    {
                        TrimIt=It;
                        ++TrimIt;
                    }
                }

                return TrimIt;
            }

            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_end_iter_select(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace,
                std::bidirectional_iterator_tag )
            {
                for( ForwardIteratorT It=InEnd; It!=InBegin; )
                {
                    if ( !IsSpace(*(--It)) )
                        return ++It;
                }

                return InBegin;
            }

            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_begin(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace )
            {
                ForwardIteratorT It=InBegin;
                for(; It!=InEnd; ++It )
                {
                    if (!IsSpace(*It))
                        return It;
                }

                return It;
            }


            template< typename ForwardIteratorT, typename PredicateT >
            inline ForwardIteratorT trim_end(
                ForwardIteratorT InBegin,
                ForwardIteratorT InEnd,
                PredicateT IsSpace )
            {
                typedef typename boost::detail::
                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
            }


        }
    }
}
# 23 "/usr/include/boost/algorithm/string/trim.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/classification.hpp" 1 3 4
# 15 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
# 1 "/usr/include/c++/4.8/locale" 1 3 4
# 36 "/usr/include/c++/4.8/locale" 3 4
       
# 37 "/usr/include/c++/4.8/locale" 3




# 1 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 1 3
# 37 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
       
# 38 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3

# 1 "/usr/include/c++/4.8/ctime" 1 3
# 39 "/usr/include/c++/4.8/ctime" 3
       
# 40 "/usr/include/c++/4.8/ctime" 3
# 40 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 52 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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);
# 210 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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 ();



}


# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/time_members.h" 1 3
# 37 "/usr/include/i386-linux-gnu/c++/4.8/bits/time_members.h" 3
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);
    }


}
# 349 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

# 367 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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;
# 389 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 406 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 430 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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); }
# 455 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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); }
# 483 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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); }
# 512 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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); }
# 538 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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() { }
# 558 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual dateorder
      do_date_order() const;
# 576 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 595 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 614 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 633 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 652 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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() { }
    };
# 714 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 735 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 754 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
   const _CharT* __beg, const _CharT* __end) const;
# 774 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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()
      { }
# 801 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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() { }
    };
# 840 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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;
 }
    }
# 933 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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;
# 962 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(); }
# 975 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 990 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(__cloc, __s); }
# 1004 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1017 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1047 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1060 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 1077 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 1094 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 1110 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 1146 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 1168 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1180 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1193 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1206 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 1219 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 1232 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 1246 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 1260 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 1274 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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;


# 1369 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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;
# 1391 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 1421 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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); }
# 1452 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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() { }
# 1475 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 1487 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;
# 1498 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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;
# 1520 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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;
# 1541 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 1561 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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); }
# 1584 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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() { }
# 1618 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 1642 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;
# 1653 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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;
  };
# 1694 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
  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;
# 1722 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      messages(size_t __refs = 0);
# 1736 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1749 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 1767 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 1785 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 1796 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 1816 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 1835 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 3
      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()
      { }
    };


}


# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/messages_members.h" 1 3
# 36 "/usr/include/i386-linux-gnu/c++/4.8/bits/messages_members.h" 3
# 1 "/usr/include/libintl.h" 1 3 4
# 34 "/usr/include/libintl.h" 3 4
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 ();
# 121 "/usr/include/libintl.h" 3 4
}
# 37 "/usr/include/i386-linux-gnu/c++/4.8/bits/messages_members.h" 2 3

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);
  }
     }


}
# 1899 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/include/c++/4.8/bits/codecvt.h" 1 3
# 39 "/usr/include/c++/4.8/bits/codecvt.h" 3
       
# 40 "/usr/include/c++/4.8/bits/codecvt.h" 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 67 "/usr/include/c++/4.8/bits/codecvt.h" 3
  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;
# 115 "/usr/include/c++/4.8/bits/codecvt.h" 3
      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);
      }
# 154 "/usr/include/c++/4.8/bits/codecvt.h" 3
      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); }
# 195 "/usr/include/c++/4.8/bits/codecvt.h" 3
      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() { }
# 236 "/usr/include/c++/4.8/bits/codecvt.h" 3
      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;
    };
# 275 "/usr/include/c++/4.8/bits/codecvt.h" 3
   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),
 _M_c_locale_codecvt(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>
    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&);




}
# 1902 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 2 3

# 1 "/usr/include/c++/4.8/bits/locale_facets_nonio.tcc" 1 3
# 33 "/usr/include/c++/4.8/bits/locale_facets_nonio.tcc" 3
       
# 34 "/usr/include/c++/4.8/bits/locale_facets_nonio.tcc" 3

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;
 }
    }



  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;
      }
# 362 "/usr/include/c++/4.8/bits/locale_facets_nonio.tcc" 3
  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;
      }
# 567 "/usr/include/c++/4.8/bits/locale_facets_nonio.tcc" 3
  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);
 }
# 599 "/usr/include/c++/4.8/bits/locale_facets_nonio.tcc" 3
      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 money_get<char>;
  extern template class 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 money_get<wchar_t>;
  extern template class 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&);




}
# 1904 "/usr/include/c++/4.8/bits/locale_facets_nonio.h" 2 3
# 42 "/usr/include/c++/4.8/locale" 2 3
# 16 "/usr/include/boost/algorithm/string/classification.hpp" 2 3 4


# 1 "/usr/include/boost/algorithm/string/detail/classification.hpp" 1 3 4
# 22 "/usr/include/boost/algorithm/string/detail/classification.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/predicate_facade.hpp" 1 3 4
# 23 "/usr/include/boost/algorithm/string/predicate_facade.hpp" 3 4
namespace boost {
    namespace algorithm {
# 35 "/usr/include/boost/algorithm/string/predicate_facade.hpp" 3 4
        template<typename Derived>
        struct predicate_facade {};

    }
}
# 23 "/usr/include/boost/algorithm/string/detail/classification.hpp" 2 3 4


namespace boost {
    namespace algorithm {
        namespace detail {




            struct is_classifiedF :
                public predicate_facade<is_classifiedF>
            {

                typedef bool result_type;


                is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
                    m_Type(Type), m_Locale(Loc) {}

                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
                }
# 56 "/usr/include/boost/algorithm/string/detail/classification.hpp" 3 4
            private:
                std::ctype_base::mask m_Type;
                std::locale m_Locale;
            };






            template<typename CharT>
            struct is_any_ofF :
                public predicate_facade<is_any_ofF<CharT> >
            {
            private:

                typedef typename ::boost::remove_const<CharT>::type set_value_type;

            public:

                typedef bool result_type;


                template<typename RangeT>
                is_any_ofF( const RangeT& Range ) : m_Size(0)
                {

                    m_Storage.m_dynSet=0;

                    std::size_t Size=::boost::distance(Range);
                    m_Size=Size;
                    set_value_type* Storage=0;

                    if(use_fixed_storage(m_Size))
                    {

                        Storage=&m_Storage.m_fixSet[0];
                    }
                    else
                    {

                        m_Storage.m_dynSet=new set_value_type[m_Size];
                        Storage=m_Storage.m_dynSet;
                    }


                    ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
                    ::std::sort(Storage, Storage+m_Size);
                }


                is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
                {

                    m_Storage.m_dynSet=0;
                    const set_value_type* SrcStorage=0;
                    set_value_type* DestStorage=0;

                    if(use_fixed_storage(m_Size))
                    {

                        DestStorage=&m_Storage.m_fixSet[0];
                        SrcStorage=&Other.m_Storage.m_fixSet[0];
                    }
                    else
                    {

                        m_Storage.m_dynSet=new set_value_type[m_Size];
                        DestStorage=m_Storage.m_dynSet;
                        SrcStorage=Other.m_Storage.m_dynSet;
                    }


                    ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
                }


                ~is_any_ofF()
                {
                    if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
                    {
                        delete [] m_Storage.m_dynSet;
                    }
                }


                is_any_ofF& operator=(const is_any_ofF& Other)
                {

                    if(this==&Other) return *this;


                    const set_value_type* SrcStorage;
                    set_value_type* DestStorage;

                    if(use_fixed_storage(Other.m_Size))
                    {

                        DestStorage=&m_Storage.m_fixSet[0];
                        SrcStorage=&Other.m_Storage.m_fixSet[0];


                        if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
                        {
                            delete [] m_Storage.m_dynSet;
                        }


                        m_Size=Other.m_Size;
                    }
                    else
                    {

                        SrcStorage=Other.m_Storage.m_dynSet;


                        if(use_fixed_storage(m_Size))
                        {

                            set_value_type* pTemp=new set_value_type[Other.m_Size];
                            DestStorage=pTemp;
                            m_Storage.m_dynSet=pTemp;
                            m_Size=Other.m_Size;
                        }
                        else
                        {

                            if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
                            {

                                DestStorage=m_Storage.m_dynSet;
                                m_Size=Other.m_Size;
                            }
                            else
                            {

                                set_value_type* pTemp=new set_value_type[Other.m_Size];
                                DestStorage=pTemp;


                                if(m_Storage.m_dynSet!=0)
                                {
                                    delete [] m_Storage.m_dynSet;
                                }

                                m_Storage.m_dynSet=pTemp;

                                m_Size=Other.m_Size;
                            }
                        }
                    }


                    ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);

                    return *this;
                }


                template<typename Char2T>
                bool operator()( Char2T Ch ) const
                {
                    const set_value_type* Storage=
                        (use_fixed_storage(m_Size))
                        ? &m_Storage.m_fixSet[0]
                        : m_Storage.m_dynSet;

                    return ::std::binary_search(Storage, Storage+m_Size, Ch);
                }
            private:

                static bool use_fixed_storage(std::size_t size)
                {
                    return size<=sizeof(set_value_type*)*2;
                }


            private:


                union
                {
                    set_value_type* m_dynSet;
                    set_value_type m_fixSet[sizeof(set_value_type*)*2];
                }
                m_Storage;


                ::std::size_t m_Size;
            };






            template<typename CharT>
            struct is_from_rangeF :
                public predicate_facade< is_from_rangeF<CharT> >
            {

                typedef bool result_type;


                is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}


                template<typename Char2T>
                bool operator()( Char2T Ch ) const
                {
                    return ( m_From <= Ch ) && ( Ch <= m_To );
                }

            private:
                CharT m_From;
                CharT m_To;
            };


            template<typename Pred1T, typename Pred2T>
            struct pred_andF :
                public predicate_facade< pred_andF<Pred1T,Pred2T> >
            {
            public:


                typedef bool result_type;


                pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
                    m_Pred1(Pred1), m_Pred2(Pred2) {}


                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return m_Pred1(Ch) && m_Pred2(Ch);
                }

            private:
                Pred1T m_Pred1;
                Pred2T m_Pred2;
            };


            template<typename Pred1T, typename Pred2T>
            struct pred_orF :
                public predicate_facade< pred_orF<Pred1T,Pred2T> >
            {
            public:

                typedef bool result_type;


                pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
                    m_Pred1(Pred1), m_Pred2(Pred2) {}


                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return m_Pred1(Ch) || m_Pred2(Ch);
                }

            private:
                Pred1T m_Pred1;
                Pred2T m_Pred2;
            };


            template< typename PredT >
            struct pred_notF :
                public predicate_facade< pred_notF<PredT> >
            {
            public:

                typedef bool result_type;


                pred_notF( PredT Pred ) : m_Pred(Pred) {}


                template<typename CharT>
                bool operator()( CharT Ch ) const
                {
                    return !m_Pred(Ch);
                }

            private:
                PredT m_Pred;
            };

        }
    }
}
# 19 "/usr/include/boost/algorithm/string/classification.hpp" 2 3 4
# 29 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
namespace boost {
    namespace algorithm {
# 43 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(Type, Loc);
        }
# 56 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_space(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::space, Loc);
        }
# 69 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_alnum(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::alnum, Loc);
        }
# 82 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_alpha(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::alpha, Loc);
        }
# 95 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_cntrl(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
        }
# 108 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_digit(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::digit, Loc);
        }
# 121 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_graph(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::graph, Loc);
        }
# 134 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_lower(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::lower, Loc);
        }
# 147 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_print(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::print, Loc);
        }
# 160 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_punct(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::punct, Loc);
        }
# 173 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_upper(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::upper, Loc);
        }
# 186 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        inline detail::is_classifiedF
        is_xdigit(const std::locale& Loc=std::locale())
        {
            return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
        }
# 200 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename RangeT>
        inline detail::is_any_ofF<
            typename range_value<RangeT>::type>
        is_any_of( const RangeT& Set )
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
            return detail::is_any_ofF<typename range_value<RangeT>::type>(lit_set);
        }
# 218 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename CharT>
        inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
        {
            return detail::is_from_rangeF<CharT>(From,To);
        }
# 236 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename Pred1T, typename Pred2T>
        inline detail::pred_andF<Pred1T, Pred2T>
        operator&&(
            const predicate_facade<Pred1T>& Pred1,
            const predicate_facade<Pred2T>& Pred2 )
        {



            return detail::pred_andF<Pred1T,Pred2T>(
                *static_cast<const Pred1T*>(&Pred1),
                *static_cast<const Pred2T*>(&Pred2) );
        }
# 260 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename Pred1T, typename Pred2T>
        inline detail::pred_orF<Pred1T, Pred2T>
        operator||(
            const predicate_facade<Pred1T>& Pred1,
            const predicate_facade<Pred2T>& Pred2 )
        {



            return detail::pred_orF<Pred1T,Pred2T>(
                *static_cast<const Pred1T*>(&Pred1),
                *static_cast<const Pred2T*>(&Pred2));
        }
# 282 "/usr/include/boost/algorithm/string/classification.hpp" 3 4
        template<typename PredT>
        inline detail::pred_notF<PredT>
        operator!( const predicate_facade<PredT>& Pred )
        {



            return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred));
        }

    }


    using algorithm::is_classified;
    using algorithm::is_space;
    using algorithm::is_alnum;
    using algorithm::is_alpha;
    using algorithm::is_cntrl;
    using algorithm::is_digit;
    using algorithm::is_graph;
    using algorithm::is_lower;
    using algorithm::is_upper;
    using algorithm::is_print;
    using algorithm::is_punct;
    using algorithm::is_xdigit;
    using algorithm::is_any_of;
    using algorithm::is_from_range;

}
# 24 "/usr/include/boost/algorithm/string/trim.hpp" 2 3 4
# 38 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
namespace boost {
    namespace algorithm {
# 60 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
        inline OutputIteratorT trim_left_copy_if(
            OutputIteratorT Output,
            const RangeT& Input,
            PredicateT IsSpace)
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));

            std::copy(
                ::boost::algorithm::detail::trim_begin(
                    ::boost::begin(lit_range),
                    ::boost::end(lit_range),
                    IsSpace ),
                ::boost::end(lit_range),
                Output);

            return Output;
        }





        template<typename SequenceT, typename PredicateT>
        inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
        {
            return SequenceT(
                ::boost::algorithm::detail::trim_begin(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace ),
                ::boost::end(Input));
        }
# 105 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
        {
            return
                ::boost::algorithm::trim_left_copy_if(
                    Input,
                    is_space(Loc));
        }
# 123 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT, typename PredicateT>
        inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
        {
            Input.erase(
                ::boost::begin(Input),
                ::boost::algorithm::detail::trim_begin(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace));
        }
# 142 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::trim_left_if(
                Input,
                is_space(Loc));
        }
# 168 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
        inline OutputIteratorT trim_right_copy_if(
            OutputIteratorT Output,
            const RangeT& Input,
            PredicateT IsSpace )
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));

            std::copy(
                ::boost::begin(lit_range),
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(lit_range),
                    ::boost::end(lit_range),
                    IsSpace ),
                Output );

            return Output;
        }





        template<typename SequenceT, typename PredicateT>
        inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
        {
            return SequenceT(
                ::boost::begin(Input),
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace)
                );
        }
# 214 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
        {
            return
                ::boost::algorithm::trim_right_copy_if(
                    Input,
                    is_space(Loc));
        }
# 233 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT, typename PredicateT>
        inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
        {
            Input.erase(
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    IsSpace ),
                ::boost::end(Input)
                );
        }
# 254 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::trim_right_if(
                Input,
                is_space(Loc) );
        }
# 280 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT, typename PredicateT>
        inline OutputIteratorT trim_copy_if(
            OutputIteratorT Output,
            const RangeT& Input,
            PredicateT IsSpace)
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));

            typename
                range_const_iterator<RangeT>::type TrimEnd=
                ::boost::algorithm::detail::trim_end(
                    ::boost::begin(lit_range),
                    ::boost::end(lit_range),
                    IsSpace);

            std::copy(
                detail::trim_begin(
                    ::boost::begin(lit_range), TrimEnd, IsSpace),
                TrimEnd,
                Output
                );

            return Output;
        }





        template<typename SequenceT, typename PredicateT>
        inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
        {
            typename
                range_const_iterator<SequenceT>::type TrimEnd=
                    ::boost::algorithm::detail::trim_end(
                        ::boost::begin(Input),
                        ::boost::end(Input),
                        IsSpace);

            return SequenceT(
                detail::trim_begin(
                    ::boost::begin(Input),
                    TrimEnd,
                    IsSpace),
                TrimEnd
                );
        }
# 339 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
        {
            return
                ::boost::algorithm::trim_copy_if(
                    Input,
                    is_space(Loc) );
        }
# 357 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT, typename PredicateT>
        inline void trim_if(SequenceT& Input, PredicateT IsSpace)
        {
            ::boost::algorithm::trim_right_if( Input, IsSpace );
            ::boost::algorithm::trim_left_if( Input, IsSpace );
        }
# 372 "/usr/include/boost/algorithm/string/trim.hpp" 3 4
        template<typename SequenceT>
        inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::trim_if(
                Input,
                is_space( Loc ) );
        }

    }


    using algorithm::trim_left;
    using algorithm::trim_left_if;
    using algorithm::trim_left_copy;
    using algorithm::trim_left_copy_if;
    using algorithm::trim_right;
    using algorithm::trim_right_if;
    using algorithm::trim_right_copy;
    using algorithm::trim_right_copy_if;
    using algorithm::trim;
    using algorithm::trim_if;
    using algorithm::trim_copy;
    using algorithm::trim_copy_if;

}
# 20 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/case_conv.hpp" 1 3 4
# 17 "/usr/include/boost/algorithm/string/case_conv.hpp" 3 4
# 1 "/usr/include/boost/iterator/transform_iterator.hpp" 1 3 4
# 23 "/usr/include/boost/iterator/transform_iterator.hpp" 3 4
# 1 "/usr/include/boost/utility/result_of.hpp" 1 3 4
# 18 "/usr/include/boost/utility/result_of.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_shifted_params.hpp" 1 3 4
# 19 "/usr/include/boost/utility/result_of.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/intercept.hpp" 1 3 4
# 20 "/usr/include/boost/utility/result_of.hpp" 2 3 4
# 57 "/usr/include/boost/utility/result_of.hpp" 3 4
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;
# 120 "/usr/include/boost/utility/result_of.hpp" 3 4
template<typename T>
struct result_of_always_void
{
  typedef void type;
};

template<typename F, typename Enable = void> 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
{};

}


# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F >
struct result_of<F()>
    : tr1_result_of<F()> { };
# 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0>
struct result_of<F( T0)>
    : tr1_result_of<F( T0)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1>
struct result_of<F( T0 , T1)>
    : tr1_result_of<F( T0 , T1)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2>
struct result_of<F( T0 , T1 , T2)>
    : tr1_result_of<F( T0 , T1 , T2)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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;
};


}
# 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
    : 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 , T10),
            (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 , T10),
            (boost::detail::has_result_type<F>::value)> >::type { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
struct result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)>
    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 , typename T10>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), 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 , typename T10>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), 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 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10),
                 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 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
                     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 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
                     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 , typename T10>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 103 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
    : 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 , T10 , T11),
            (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 , T10 , T11),
            (boost::detail::has_result_type<F>::value)> >::type { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)>
    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 , typename T10 , typename T11>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), 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 , typename T10 , typename T11>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), 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 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11),
                 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 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
                     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 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
                     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 , typename T10 , typename T11>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 108 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
    : 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 , T10 , T11 , T12),
            (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 , T10 , T11 , T12),
            (boost::detail::has_result_type<F>::value)> >::type { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)>
    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), 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 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), 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 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12),
                 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 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
                     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 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
                     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 , typename T10 , typename T11 , typename T12>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 113 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
    : 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 , T10 , T11 , T12 , T13),
            (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 , T10 , T11 , T12 , T13),
            (boost::detail::has_result_type<F>::value)> >::type { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)>
    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), 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 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), 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 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13),
                 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 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
                     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 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
                     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 , typename T10 , typename T11 , typename T12 , typename T13>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 118 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
    : 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 , T10 , T11 , T12 , T13 , T14),
            (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 , T10 , T11 , T12 , T13 , T14),
            (boost::detail::has_result_type<F>::value)> >::type { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)>
    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14),
                 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
                     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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
                     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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 123 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 1 3 4
# 26 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
    : 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 , T10 , T11 , T12 , T13 , T14 , T15),
            (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 , T10 , T11 , T12 , T13 , T14 , T15),
            (boost::detail::has_result_type<F>::value)> >::type { };
# 145 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
template<typename F , 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 result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)>
    : tr1_result_of<F( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { };
# 156 "/usr/include/boost/utility/detail/result_of_iterate.hpp" 3 4
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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (&)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15), 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15),
                 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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
                     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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
                     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 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
struct tr1_result_of_impl<R (T0::*)
                     ( T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)
                     const volatile,
                 FArgs, false>
{
  typedef R type;
};


}
# 128 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 180 "/usr/include/boost/utility/result_of.hpp" 2 3 4





}
# 24 "/usr/include/boost/iterator/transform_iterator.hpp" 2 3 4






# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 31 "/usr/include/boost/iterator/transform_iterator.hpp" 2 3 4


namespace boost
{
  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
  class transform_iterator;

  namespace detail
  {

    template <class UnaryFunc, class Iterator, class Reference, class Value>
    struct transform_iterator_base
    {
     private:


        typedef typename ia_dflt_help<
            Reference
          , result_of<const UnaryFunc(typename std::iterator_traits<Iterator>::reference)>
        >::type reference;






        typedef typename ia_dflt_help<
            Value
          , remove_reference<reference>
        >::type cv_value_type;

     public:
        typedef iterator_adaptor<
            transform_iterator<UnaryFunc, Iterator, Reference, Value>
          , Iterator
          , cv_value_type
          , use_default
          , reference
        > type;
    };
  }

  template <class UnaryFunc, class Iterator, class Reference, class Value>
  class transform_iterator
    : public boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
  {
    typedef typename
    boost::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
    super_t;

    friend class iterator_core_access;

  public:
    transform_iterator() { }

    transform_iterator(Iterator const& x, UnaryFunc f)
      : super_t(x), m_f(f) { }

    explicit transform_iterator(Iterator const& x)
      : super_t(x)
    {





        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_class<UnaryFunc>::value) == 0 ? false : true) >)> boost_static_assert_typedef_97;

    }

    template <
        class OtherUnaryFunction
      , class OtherIterator
      , class OtherReference
      , class OtherValue>
    transform_iterator(
         transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0

       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0

    )
      : super_t(t.base()), m_f(t.functor())
   {}

    UnaryFunc functor() const
      { return m_f; }

  private:
    typename super_t::reference dereference() const
    { return m_f(*this->base()); }



    UnaryFunc m_f;
  };

  template <class UnaryFunc, class Iterator>
  transform_iterator<UnaryFunc, Iterator>
  make_transform_iterator(Iterator it, UnaryFunc fun)
  {
      return transform_iterator<UnaryFunc, Iterator>(it, fun);
  }
# 142 "/usr/include/boost/iterator/transform_iterator.hpp" 3 4
  template <class UnaryFunc, class Iterator>



  typename iterators::enable_if<

      is_class<UnaryFunc>
    , transform_iterator<UnaryFunc, Iterator>



  >::type
  make_transform_iterator(Iterator it)
  {
      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
  }
# 168 "/usr/include/boost/iterator/transform_iterator.hpp" 3 4
}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 171 "/usr/include/boost/iterator/transform_iterator.hpp" 2 3 4
# 18 "/usr/include/boost/algorithm/string/case_conv.hpp" 2 3 4






# 1 "/usr/include/boost/algorithm/string/detail/case_conv.hpp" 1 3 4
# 20 "/usr/include/boost/algorithm/string/detail/case_conv.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {
# 32 "/usr/include/boost/algorithm/string/detail/case_conv.hpp" 3 4
            template<typename CharT>
            struct to_lowerF : public std::unary_function<CharT, CharT>
            {

                to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}


                CharT operator ()( CharT Ch ) const
                {



                        return std::tolower<CharT>( Ch, *m_Loc );

                }
            private:
                const std::locale* m_Loc;
            };


            template<typename CharT>
            struct to_upperF : public std::unary_function<CharT, CharT>
            {

                to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}


                CharT operator ()( CharT Ch ) const
                {



                        return std::toupper<CharT>( Ch, *m_Loc );

                }
            private:
                const std::locale* m_Loc;
            };
# 78 "/usr/include/boost/algorithm/string/detail/case_conv.hpp" 3 4
            template<typename OutputIteratorT, typename RangeT, typename FunctorT>
            OutputIteratorT transform_range_copy(
                OutputIteratorT Output,
                const RangeT& Input,
                FunctorT Functor)
            {
                return std::transform(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    Output,
                    Functor);
            }


            template<typename RangeT, typename FunctorT>
            void transform_range(
                const RangeT& Input,
                FunctorT Functor)
            {
                std::transform(
                    ::boost::begin(Input),
                    ::boost::end(Input),
                    ::boost::begin(Input),
                    Functor);
            }

            template<typename SequenceT, typename RangeT, typename FunctorT>
            inline SequenceT transform_range_copy(
                const RangeT& Input,
                FunctorT Functor)
            {
                return SequenceT(
                    ::boost::make_transform_iterator(
                        ::boost::begin(Input),
                        Functor),
                    ::boost::make_transform_iterator(
                        ::boost::end(Input),
                        Functor));
            }

        }
    }
}
# 25 "/usr/include/boost/algorithm/string/case_conv.hpp" 2 3 4







namespace boost {
    namespace algorithm {
# 53 "/usr/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT>
        inline OutputIteratorT
        to_lower_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy(
               Output,
               ::boost::as_literal(Input),
               ::boost::algorithm::detail::to_lowerF<
                    typename range_value<RangeT>::type >(Loc));
        }





        template<typename SequenceT>
        inline SequenceT to_lower_copy(
            const SequenceT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
                Input,
                ::boost::algorithm::detail::to_lowerF<
                    typename range_value<SequenceT>::type >(Loc));
        }
# 90 "/usr/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename WritableRangeT>
        inline void to_lower(
            WritableRangeT& Input,
            const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::detail::transform_range(
                ::boost::as_literal(Input),
                ::boost::algorithm::detail::to_lowerF<
                    typename range_value<WritableRangeT>::type >(Loc));
        }
# 118 "/usr/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT>
        inline OutputIteratorT
        to_upper_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy(
               Output,
               ::boost::as_literal(Input),
               ::boost::algorithm::detail::to_upperF<
                    typename range_value<RangeT>::type >(Loc));
        }





        template<typename SequenceT>
        inline SequenceT to_upper_copy(
            const SequenceT& Input,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
                Input,
                ::boost::algorithm::detail::to_upperF<
                    typename range_value<SequenceT>::type >(Loc));
        }
# 155 "/usr/include/boost/algorithm/string/case_conv.hpp" 3 4
        template<typename WritableRangeT>
        inline void to_upper(
            WritableRangeT& Input,
            const std::locale& Loc=std::locale())
        {
            ::boost::algorithm::detail::transform_range(
                ::boost::as_literal(Input),
                ::boost::algorithm::detail::to_upperF<
                    typename range_value<WritableRangeT>::type >(Loc));
        }

    }


    using algorithm::to_lower;
    using algorithm::to_lower_copy;
    using algorithm::to_upper;
    using algorithm::to_upper_copy;

}
# 21 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/predicate.hpp" 1 3 4
# 22 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/compare.hpp" 1 3 4
# 24 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
namespace boost {
    namespace algorithm {
# 34 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
        struct is_equal
        {




            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1==Arg2;
            }
        };






        struct is_iequal
        {




            is_iequal( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}





            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {



                    return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);

            }

        private:
            std::locale m_Loc;
        };
# 86 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
        struct is_less
        {




            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1<Arg2;
            }
        };







        struct is_iless
        {




            is_iless( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}





            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {



                    return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);

            }

        private:
            std::locale m_Loc;
        };
# 139 "/usr/include/boost/algorithm/string/compare.hpp" 3 4
        struct is_not_greater
        {




            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {
                return Arg1<=Arg2;
            }
        };







        struct is_not_igreater
        {




            is_not_igreater( const std::locale& Loc=std::locale() ) :
                m_Loc( Loc ) {}





            template< typename T1, typename T2 >
                bool operator()( const T1& Arg1, const T2& Arg2 ) const
            {



                    return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);

            }

        private:
            std::locale m_Loc;
        };


    }


    using algorithm::is_equal;
    using algorithm::is_iequal;
    using algorithm::is_less;
    using algorithm::is_iless;
    using algorithm::is_not_greater;
    using algorithm::is_not_igreater;

}
# 23 "/usr/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/find.hpp" 1 3 4
# 22 "/usr/include/boost/algorithm/string/find.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/finder.hpp" 1 3 4
# 22 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/constants.hpp" 1 3 4
# 14 "/usr/include/boost/algorithm/string/constants.hpp" 3 4
namespace boost {
    namespace algorithm {





    enum token_compress_mode_type
    {
        token_compress_on,
        token_compress_off
    };

    }


    using algorithm::token_compress_on;
    using algorithm::token_compress_off;

}
# 23 "/usr/include/boost/algorithm/string/finder.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/detail/finder.hpp" 1 3 4
# 24 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {
# 36 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename SearchIteratorT,typename PredicateT>
            struct first_finderF
            {
                typedef SearchIteratorT search_iterator_type;


                template< typename SearchT >
                first_finderF( const SearchT& Search, PredicateT Comp ) :
                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                first_finderF(
                        search_iterator_type SearchBegin,
                        search_iterator_type SearchEnd,
                        PredicateT Comp ) :
                    m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;
                    typedef ForwardIteratorT input_iterator_type;


                    for(input_iterator_type OuterIt=Begin;
                        OuterIt!=End;
                        ++OuterIt)
                    {

                        if( boost::empty(m_Search) )
                            return result_type( End, End );

                        input_iterator_type InnerIt=OuterIt;
                        search_iterator_type SubstrIt=m_Search.begin();
                        for(;
                            InnerIt!=End && SubstrIt!=m_Search.end();
                            ++InnerIt,++SubstrIt)
                        {
                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
                                break;
                        }


                        if ( SubstrIt==m_Search.end() )
                            return result_type( OuterIt, InnerIt );
                    }

                    return result_type( End, End );
                }

            private:
                iterator_range<search_iterator_type> m_Search;
                PredicateT m_Comp;
            };
# 100 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename SearchIteratorT, typename PredicateT>
            struct last_finderF
            {
                typedef SearchIteratorT search_iterator_type;
                typedef first_finderF<
                    search_iterator_type,
                    PredicateT> first_finder_type;


                template< typename SearchT >
                last_finderF( const SearchT& Search, PredicateT Comp ) :
                    m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
                last_finderF(
                        search_iterator_type SearchBegin,
                        search_iterator_type SearchEnd,
                        PredicateT Comp ) :
                    m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;

                    if( boost::empty(m_Search) )
                        return result_type( End, End );

                    typedef typename boost::detail::
                        iterator_traits<ForwardIteratorT>::iterator_category category;

                    return findit( Begin, End, category() );
                }

            private:

                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                findit(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    std::forward_iterator_tag ) const
                {
                    typedef ForwardIteratorT input_iterator_type;
                    typedef iterator_range<ForwardIteratorT> result_type;

                    first_finder_type first_finder(
                        m_Search.begin(), m_Search.end(), m_Comp );

                    result_type M=first_finder( Begin, End );
                    result_type Last=M;

                    while( M )
                    {
                        Last=M;
                        M=first_finder( ::boost::end(M), End );
                    }

                    return Last;
                }


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                findit(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    std::bidirectional_iterator_tag ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;
                    typedef ForwardIteratorT input_iterator_type;


                    for(input_iterator_type OuterIt=End;
                        OuterIt!=Begin; )
                    {
                        input_iterator_type OuterIt2=--OuterIt;

                        input_iterator_type InnerIt=OuterIt2;
                        search_iterator_type SubstrIt=m_Search.begin();
                        for(;
                            InnerIt!=End && SubstrIt!=m_Search.end();
                            ++InnerIt,++SubstrIt)
                        {
                            if( !( m_Comp(*InnerIt,*SubstrIt) ) )
                                break;
                        }


                        if( SubstrIt==m_Search.end() )
                            return result_type( OuterIt2, InnerIt );
                    }

                    return result_type( End, End );
                }

            private:
                iterator_range<search_iterator_type> m_Search;
                PredicateT m_Comp;
            };
# 210 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename SearchIteratorT, typename PredicateT>
            struct nth_finderF
            {
                typedef SearchIteratorT search_iterator_type;
                typedef first_finderF<
                    search_iterator_type,
                    PredicateT> first_finder_type;
                typedef last_finderF<
                    search_iterator_type,
                    PredicateT> last_finder_type;


                template< typename SearchT >
                nth_finderF(
                        const SearchT& Search,
                        int Nth,
                        PredicateT Comp) :
                    m_Search(::boost::begin(Search), ::boost::end(Search)),
                    m_Nth(Nth),
                    m_Comp(Comp) {}
                nth_finderF(
                        search_iterator_type SearchBegin,
                        search_iterator_type SearchEnd,
                        int Nth,
                        PredicateT Comp) :
                    m_Search(SearchBegin, SearchEnd),
                    m_Nth(Nth),
                    m_Comp(Comp) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    if(m_Nth>=0)
                    {
                        return find_forward(Begin, End, m_Nth);
                    }
                    else
                    {
                        return find_backward(Begin, End, -m_Nth);
                    }

                }

            private:

                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                find_forward(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    unsigned int N) const
                {
                    typedef ForwardIteratorT input_iterator_type;
                    typedef iterator_range<ForwardIteratorT> result_type;


                    if( boost::empty(m_Search) )
                        return result_type( End, End );


                    first_finder_type first_finder(
                        m_Search.begin(), m_Search.end(), m_Comp );

                    result_type M( Begin, Begin );

                    for( unsigned int n=0; n<=N; ++n )
                    {

                        M=first_finder( ::boost::end(M), End );

                        if ( !M )
                        {

                            return M;
                        }
                    }

                    return M;
                }

                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                find_backward(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End,
                    unsigned int N) const
                {
                    typedef ForwardIteratorT input_iterator_type;
                    typedef iterator_range<ForwardIteratorT> result_type;


                    if( boost::empty(m_Search) )
                        return result_type( End, End );


                    last_finder_type last_finder(
                        m_Search.begin(), m_Search.end(), m_Comp );

                    result_type M( End, End );

                    for( unsigned int n=1; n<=N; ++n )
                    {

                        M=last_finder( Begin, ::boost::begin(M) );

                        if ( !M )
                        {

                            return M;
                        }
                    }

                    return M;
                }


            private:
                iterator_range<search_iterator_type> m_Search;
                int m_Nth;
                PredicateT m_Comp;
            };



            template<typename ForwardIteratorT>
                iterator_range<ForwardIteratorT>
            find_head_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::forward_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                input_iterator_type It=Begin;
                for(
                    unsigned int Index=0;
                    Index<N && It!=End; ++Index,++It ) {};

                return result_type( Begin, It );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_head_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::random_access_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
                    return result_type( Begin, End );

                return result_type(Begin,Begin+N);
            }


            template<typename ForwardIteratorT>
                iterator_range<ForwardIteratorT>
            find_head_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N )
            {
                typedef typename boost::detail::
                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::forward_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                unsigned int Index=0;
                input_iterator_type It=Begin;
                input_iterator_type It2=Begin;


                for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};


                for(; It2!=End; ++It,++It2 ) {};

                return result_type( It, It2 );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::bidirectional_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                input_iterator_type It=End;
                for(
                    unsigned int Index=0;
                    Index<N && It!=Begin; ++Index,--It ) {};

                return result_type( It, End );
            }

            template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N,
                std::random_access_iterator_tag )
            {
                typedef ForwardIteratorT input_iterator_type;
                typedef iterator_range<ForwardIteratorT> result_type;

                if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
                    return result_type( Begin, End );

                return result_type( End-N, End );
            }


            template< typename ForwardIteratorT >
            iterator_range<ForwardIteratorT>
            find_tail_impl(
                ForwardIteratorT Begin,
                ForwardIteratorT End,
                unsigned int N )
            {
                typedef typename boost::detail::
                    iterator_traits<ForwardIteratorT>::iterator_category category;

                return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
            }
# 473 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            struct head_finderF
            {

                head_finderF( int N ) : m_N(N) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    if(m_N>=0)
                    {
                        return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
                    }
                    else
                    {
                        iterator_range<ForwardIteratorT> Res=
                            ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );

                        return ::boost::make_iterator_range(Begin, Res.begin());
                    }
                }

            private:
                int m_N;
            };
# 511 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            struct tail_finderF
            {

                tail_finderF( int N ) : m_N(N) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    if(m_N>=0)
                    {
                        return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
                    }
                    else
                    {
                        iterator_range<ForwardIteratorT> Res=
                            ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );

                        return ::boost::make_iterator_range(Res.end(), End);
                    }
                }

            private:
                int m_N;
            };
# 552 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template< typename PredicateT >
            struct token_finderF
            {

                token_finderF(
                    PredicateT Pred,
                    token_compress_mode_type eCompress=token_compress_off ) :
                        m_Pred(Pred), m_eCompress(eCompress) {}


                template< typename ForwardIteratorT >
                iterator_range<ForwardIteratorT>
                operator()(
                    ForwardIteratorT Begin,
                    ForwardIteratorT End ) const
                {
                    typedef iterator_range<ForwardIteratorT> result_type;

                    ForwardIteratorT It=std::find_if( Begin, End, m_Pred );

                    if( It==End )
                    {
                        return result_type( End, End );
                    }
                    else
                    {
                        ForwardIteratorT It2=It;

                        if( m_eCompress==token_compress_on )
                        {

                            while( It2!=End && m_Pred(*It2) ) ++It2;
                        }
                        else
                        {

                            ++It2;
                        }

                        return result_type( It, It2 );
                    }
                }

            private:
                PredicateT m_Pred;
                token_compress_mode_type m_eCompress;
            };
# 607 "/usr/include/boost/algorithm/string/detail/finder.hpp" 3 4
            template<typename ForwardIterator1T>
            struct range_finderF
            {
                typedef ForwardIterator1T input_iterator_type;
                typedef iterator_range<input_iterator_type> result_type;


                range_finderF(
                    input_iterator_type Begin,
                    input_iterator_type End ) : m_Range(Begin, End) {}

                range_finderF(const iterator_range<input_iterator_type>& Range) :
                    m_Range(Range) {}


                template< typename ForwardIterator2T >
                iterator_range<ForwardIterator2T>
                operator()(
                    ForwardIterator2T,
                    ForwardIterator2T ) const
                {





                    return m_Range;

                }

            private:
                iterator_range<input_iterator_type> m_Range;
            };


        }
    }
}
# 24 "/usr/include/boost/algorithm/string/finder.hpp" 2 3 4
# 34 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        template<typename RangeT>
        inline detail::first_finderF<
            typename range_const_iterator<RangeT>::type,
            is_equal>
        first_finder( const RangeT& Search )
        {
            return
                detail::first_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                        is_equal>( ::boost::as_literal(Search), is_equal() ) ;
        }





        template<typename RangeT,typename PredicateT>
        inline detail::first_finderF<
            typename range_const_iterator<RangeT>::type,
            PredicateT>
        first_finder(
            const RangeT& Search, PredicateT Comp )
        {
            return
                detail::first_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    PredicateT>( ::boost::as_literal(Search), Comp );
        }
# 90 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        template<typename RangeT>
        inline detail::last_finderF<
            typename range_const_iterator<RangeT>::type,
            is_equal>
        last_finder( const RangeT& Search )
        {
            return
                detail::last_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    is_equal>( ::boost::as_literal(Search), is_equal() );
        }




        template<typename RangeT, typename PredicateT>
        inline detail::last_finderF<
            typename range_const_iterator<RangeT>::type,
            PredicateT>
        last_finder( const RangeT& Search, PredicateT Comp )
        {
            return
                detail::last_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    PredicateT>( ::boost::as_literal(Search), Comp ) ;
        }
# 130 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        template<typename RangeT>
        inline detail::nth_finderF<
            typename range_const_iterator<RangeT>::type,
            is_equal>
        nth_finder(
            const RangeT& Search,
            int Nth)
        {
            return
                detail::nth_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
        }




        template<typename RangeT, typename PredicateT>
        inline detail::nth_finderF<
            typename range_const_iterator<RangeT>::type,
            PredicateT>
        nth_finder(
            const RangeT& Search,
            int Nth,
            PredicateT Comp )
        {
            return
                detail::nth_finderF<
                    typename
                        range_const_iterator<RangeT>::type,
                    PredicateT>( ::boost::as_literal(Search), Nth, Comp );
        }
# 175 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        inline detail::head_finderF
        head_finder( int N )
        {
            return detail::head_finderF(N);
        }
# 192 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        inline detail::tail_finderF
        tail_finder( int N )
        {
            return detail::tail_finderF(N);
        }
# 216 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        template< typename PredicateT >
        inline detail::token_finderF<PredicateT>
        token_finder(
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off )
        {
            return detail::token_finderF<PredicateT>( Pred, eCompress );
        }
# 236 "/usr/include/boost/algorithm/string/finder.hpp" 3 4
        template< typename ForwardIteratorT >
        inline detail::range_finderF<ForwardIteratorT>
        range_finder(
            ForwardIteratorT Begin,
            ForwardIteratorT End )
        {
            return detail::range_finderF<ForwardIteratorT>( Begin, End );
        }





        template< typename ForwardIteratorT >
        inline detail::range_finderF<ForwardIteratorT>
        range_finder( iterator_range<ForwardIteratorT> Range )
        {
            return detail::range_finderF<ForwardIteratorT>( Range );
        }

    }


    using algorithm::first_finder;
    using algorithm::last_finder;
    using algorithm::nth_finder;
    using algorithm::head_finder;
    using algorithm::tail_finder;
    using algorithm::token_finder;
    using algorithm::range_finder;

}
# 23 "/usr/include/boost/algorithm/string/find.hpp" 2 3 4
# 32 "/usr/include/boost/algorithm/string/find.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT, typename FinderT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find(
            RangeT& Input,
            const FinderT& Finder)
        {
            iterator_range<typename range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            return Finder(::boost::begin(lit_input),::boost::end(lit_input));
        }
# 77 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        find_first(
            Range1T& Input,
            const Range2T& Search)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
        }
# 103 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        ifind_first(
            Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
        }
# 130 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        find_last(
            Range1T& Input,
            const Range2T& Search)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
        }
# 156 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        ifind_last(
            Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
        }
# 184 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        find_nth(
            Range1T& Input,
            const Range2T& Search,
            int Nth)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
        }
# 214 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline iterator_range<
            typename range_iterator<Range1T>::type>
        ifind_nth(
            Range1T& Input,
            const Range2T& Search,
            int Nth,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
        }
# 246 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find_head(
            RangeT& Input,
            int N)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
        }
# 277 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find_tail(
            RangeT& Input,
            int N)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
        }
# 306 "/usr/include/boost/algorithm/string/find.hpp" 3 4
        template<typename RangeT, typename PredicateT>
        inline iterator_range<
            typename range_iterator<RangeT>::type>
        find_token(
            RangeT& Input,
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off)
        {
            return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
        }

    }


    using algorithm::find;
    using algorithm::find_first;
    using algorithm::ifind_first;
    using algorithm::find_last;
    using algorithm::ifind_last;
    using algorithm::find_nth;
    using algorithm::ifind_nth;
    using algorithm::find_head;
    using algorithm::find_tail;
    using algorithm::find_token;

}
# 24 "/usr/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/detail/predicate.hpp" 1 3 4
# 17 "/usr/include/boost/algorithm/string/detail/predicate.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template<
                typename ForwardIterator1T,
                typename ForwardIterator2T,
                typename PredicateT>
            inline bool ends_with_iter_select(
                ForwardIterator1T Begin,
                ForwardIterator1T End,
                ForwardIterator2T SubBegin,
                ForwardIterator2T SubEnd,
                PredicateT Comp,
                std::bidirectional_iterator_tag)
            {
                ForwardIterator1T it=End;
                ForwardIterator2T pit=SubEnd;
                for(;it!=Begin && pit!=SubBegin;)
                {
                    if( !(Comp(*(--it),*(--pit))) )
                        return false;
                }

                return pit==SubBegin;
            }

            template<
                typename ForwardIterator1T,
                typename ForwardIterator2T,
                typename PredicateT>
            inline bool ends_with_iter_select(
                ForwardIterator1T Begin,
                ForwardIterator1T End,
                ForwardIterator2T SubBegin,
                ForwardIterator2T SubEnd,
                PredicateT Comp,
                std::forward_iterator_tag)
            {
                if ( SubBegin==SubEnd )
                {

                    return true;
                }

                iterator_range<ForwardIterator1T> Result
                    =last_finder(
                        ::boost::make_iterator_range(SubBegin, SubEnd),
                        Comp)(Begin, End);

                return !Result.empty() && Result.end()==End;
            }

        }
    }
}
# 25 "/usr/include/boost/algorithm/string/predicate.hpp" 2 3 4
# 37 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
namespace boost {
    namespace algorithm {
# 56 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
            inline bool starts_with(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            typedef typename
                range_const_iterator<Range1T>::type Iterator1T;
            typedef typename
                range_const_iterator<Range2T>::type Iterator2T;

            Iterator1T InputEnd=::boost::end(lit_input);
            Iterator2T TestEnd=::boost::end(lit_test);

            Iterator1T it=::boost::begin(lit_input);
            Iterator2T pit=::boost::begin(lit_test);
            for(;
                it!=InputEnd && pit!=TestEnd;
                ++it,++pit)
            {
                if( !(Comp(*it,*pit)) )
                    return false;
            }

            return pit==TestEnd;
        }





        template<typename Range1T, typename Range2T>
        inline bool starts_with(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::starts_with(Input, Test, is_equal());
        }
# 111 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool istarts_with(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
        }
# 138 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool ends_with(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            typedef typename
                range_const_iterator<Range1T>::type Iterator1T;
            typedef typename boost::detail::
                iterator_traits<Iterator1T>::iterator_category category;

            return detail::
                ends_with_iter_select(
                    ::boost::begin(lit_input),
                    ::boost::end(lit_input),
                    ::boost::begin(lit_test),
                    ::boost::end(lit_test),
                    Comp,
                    category());
        }






        template<typename Range1T, typename Range2T>
        inline bool ends_with(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::ends_with(Input, Test, is_equal());
        }
# 188 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool iends_with(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
        }
# 212 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool contains(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            if (::boost::empty(lit_test))
            {

                return true;
            }


            bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
            return bResult;
        }





        template<typename Range1T, typename Range2T>
        inline bool contains(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::contains(Input, Test, is_equal());
        }
# 256 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool icontains(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
        }
# 283 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool equals(
            const Range1T& Input,
            const Range2T& Test,
            PredicateT Comp)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));

            typedef typename
                range_const_iterator<Range1T>::type Iterator1T;
            typedef typename
                range_const_iterator<Range2T>::type Iterator2T;

            Iterator1T InputEnd=::boost::end(lit_input);
            Iterator2T TestEnd=::boost::end(lit_test);

            Iterator1T it=::boost::begin(lit_input);
            Iterator2T pit=::boost::begin(lit_test);
            for(;
                it!=InputEnd && pit!=TestEnd;
                ++it,++pit)
            {
                if( !(Comp(*it,*pit)) )
                    return false;
            }

            return (pit==TestEnd) && (it==InputEnd);
        }





        template<typename Range1T, typename Range2T>
        inline bool equals(
            const Range1T& Input,
            const Range2T& Test)
        {
            return ::boost::algorithm::equals(Input, Test, is_equal());
        }
# 340 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool iequals(
            const Range1T& Input,
            const Range2T& Test,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
        }
# 369 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T, typename PredicateT>
        inline bool lexicographical_compare(
            const Range1T& Arg1,
            const Range2T& Arg2,
            PredicateT Pred)
        {
            iterator_range<typename range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1));
            iterator_range<typename range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));

            return std::lexicographical_compare(
                ::boost::begin(lit_arg1),
                ::boost::end(lit_arg1),
                ::boost::begin(lit_arg2),
                ::boost::end(lit_arg2),
                Pred);
        }





        template<typename Range1T, typename Range2T>
            inline bool lexicographical_compare(
            const Range1T& Arg1,
            const Range2T& Arg2)
        {
            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
        }
# 414 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename Range1T, typename Range2T>
        inline bool ilexicographical_compare(
            const Range1T& Arg1,
            const Range2T& Arg2,
            const std::locale& Loc=std::locale())
        {
            return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
        }
# 437 "/usr/include/boost/algorithm/string/predicate.hpp" 3 4
        template<typename RangeT, typename PredicateT>
        inline bool all(
            const RangeT& Input,
            PredicateT Pred)
        {
            iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            typedef typename
                range_const_iterator<RangeT>::type Iterator1T;

            Iterator1T InputEnd=::boost::end(lit_input);
            for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
            {
                if (!Pred(*It))
                    return false;
            }

            return true;
        }

    }


    using algorithm::starts_with;
    using algorithm::istarts_with;
    using algorithm::ends_with;
    using algorithm::iends_with;
    using algorithm::contains;
    using algorithm::icontains;
    using algorithm::equals;
    using algorithm::iequals;
    using algorithm::all;
    using algorithm::lexicographical_compare;
    using algorithm::ilexicographical_compare;

}
# 22 "/usr/include/boost/algorithm/string.hpp" 2 3 4

# 1 "/usr/include/boost/algorithm/string/split.hpp" 1 3 4
# 16 "/usr/include/boost/algorithm/string/split.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/iter_find.hpp" 1 3 4
# 26 "/usr/include/boost/algorithm/string/iter_find.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/concept.hpp" 1 3 4
# 23 "/usr/include/boost/algorithm/string/concept.hpp" 3 4
namespace boost {
    namespace algorithm {
# 34 "/usr/include/boost/algorithm/string/concept.hpp" 3 4
        template<typename FinderT, typename IteratorT>
        struct FinderConcept
        {
        private:
            typedef iterator_range<IteratorT> range;
        public:
            void constraints()
            {

                r=(*pF)(i,i);
            }
        private:
            range r;
            IteratorT i;
            FinderT* pF;
        };
# 61 "/usr/include/boost/algorithm/string/concept.hpp" 3 4
        template<typename FormatterT, typename FinderT, typename IteratorT>
        struct FormatterConcept
        {
        public:
            void constraints()
            {

                ::boost::begin((*pFo)( (*pF)(i,i) ));
                ::boost::end((*pFo)( (*pF)(i,i) ));
            }
        private:
            IteratorT i;
            FinderT* pF;
            FormatterT *pFo;
        };

    }
}
# 27 "/usr/include/boost/algorithm/string/iter_find.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/find_iterator.hpp" 1 3 4
# 24 "/usr/include/boost/algorithm/string/find_iterator.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/detail/find_iterator.hpp" 1 3 4
# 18 "/usr/include/boost/algorithm/string/detail/find_iterator.hpp" 3 4
# 1 "/usr/include/boost/function.hpp" 1 3 4
# 15 "/usr/include/boost/function.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iterate.hpp" 1 3 4
# 16 "/usr/include/boost/function.hpp" 2 3 4
# 24 "/usr/include/boost/function.hpp" 3 4
# 1 "/usr/include/boost/function/detail/prologue.hpp" 1 3 4
# 12 "/usr/include/boost/function/detail/prologue.hpp" 3 4
# 1 "/usr/include/c++/4.8/cassert" 1 3 4
# 41 "/usr/include/c++/4.8/cassert" 3 4
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 13 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4

# 1 "/usr/include/boost/config/no_tr1/functional.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4


# 1 "/usr/include/boost/function/function_base.hpp" 1 3 4
# 20 "/usr/include/boost/function/function_base.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 21 "/usr/include/boost/function/function_base.hpp" 2 3 4
# 1 "/usr/include/boost/integer.hpp" 1 3 4
# 22 "/usr/include/boost/integer.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 23 "/usr/include/boost/integer.hpp" 2 3 4
# 34 "/usr/include/boost/integer.hpp" 3 4
       
# 35 "/usr/include/boost/integer.hpp" 3


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< int Category > struct uint_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 uint_least_helper<1> { typedef boost::ulong_long_type least; };



  template<> struct uint_least_helper<2> { typedef unsigned long least; };
  template<> struct uint_least_helper<3> { typedef unsigned int least; };
  template<> struct uint_least_helper<4> { typedef unsigned short least; };
  template<> struct uint_least_helper<5> { 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; };
# 103 "/usr/include/boost/integer.hpp" 3
  template <> struct exact_signed_base_helper<sizeof(boost::long_long_type)* 8> { typedef boost::long_long_type exact; };
  template <> struct exact_unsigned_base_helper<sizeof(boost::ulong_long_type)* 8> { typedef boost::ulong_long_type exact; };



  }




  template< int Bits >
  struct int_t : public detail::exact_signed_base_helper<Bits>
  {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Bits <= (int)(sizeof(boost::intmax_t) * 8)) == 0 ? false : true) >)> boost_static_assert_typedef_117
                                                                                           ;
      typedef typename detail::int_least_helper
        <

          (Bits <= (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 ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Bits <= (int)(sizeof(boost::uintmax_t) * 8)) == 0 ? false : true) >)> boost_static_assert_typedef_138
                                                                                             ;
# 149 "/usr/include/boost/integer.hpp" 3
      typedef typename detail::uint_least_helper
        <

          (Bits <= (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
  {
# 242 "/usr/include/boost/integer.hpp" 3
      typedef typename detail::uint_least_helper
        <

          (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;
  };


}
# 22 "/usr/include/boost/function/function_base.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/composite_traits.hpp" 1 3 4
# 22 "/usr/include/boost/type_traits/composite_traits.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_union.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_union.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4

namespace boost {

namespace detail {
# 40 "/usr/include/boost/type_traits/is_union.hpp" 3 4
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: };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 56 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
# 23 "/usr/include/boost/type_traits/composite_traits.hpp" 2 3 4
# 28 "/usr/include/boost/function/function_base.hpp" 2 3 4
# 38 "/usr/include/boost/function/function_base.hpp" 3 4
# 1 "/usr/include/boost/function_equal.hpp" 1 3 4
# 13 "/usr/include/boost/function_equal.hpp" 3 4
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); }

}
# 39 "/usr/include/boost/function/function_base.hpp" 2 3 4
# 1 "/usr/include/boost/function/function_fwd.hpp" 1 3 4
# 28 "/usr/include/boost/function/function_fwd.hpp" 3 4
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;
}
# 40 "/usr/include/boost/function/function_base.hpp" 2 3 4
# 62 "/usr/include/boost/function/function_base.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 63 "/usr/include/boost/function/function_base.hpp" 2 3 4
# 89 "/usr/include/boost/function/function_base.hpp" 3 4
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 {};
# 615 "/usr/include/boost/function/function_base.hpp" 3 4
      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;
      }
    }
# 721 "/usr/include/boost/function/function_base.hpp" 3 4
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();
}
# 806 "/usr/include/boost/function/function_base.hpp" 3 4
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;
    }

  }
}
}
# 18 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
# 1 "/usr/include/boost/mem_fn.hpp" 1 3 4
# 22 "/usr/include/boost/mem_fn.hpp" 3 4
# 1 "/usr/include/boost/bind/mem_fn.hpp" 1 3 4
# 25 "/usr/include/boost/bind/mem_fn.hpp" 3 4
# 1 "/usr/include/boost/get_pointer.hpp" 1 3 4
# 16 "/usr/include/boost/get_pointer.hpp" 3 4
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();
}
# 46 "/usr/include/boost/get_pointer.hpp" 3 4
}
# 26 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4


namespace boost
{
# 207 "/usr/include/boost/bind/mem_fn.hpp" 3 4
namespace _mfi
{






# 1 "/usr/include/boost/bind/mem_fn_template.hpp" 1 3 4
# 21 "/usr/include/boost/bind/mem_fn_template.hpp" 3 4
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_;
    }
};
# 216 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
# 258 "/usr/include/boost/bind/mem_fn.hpp" 3 4
}
# 268 "/usr/include/boost/bind/mem_fn.hpp" 3 4
# 1 "/usr/include/boost/bind/mem_fn_cc.hpp" 1 3 4
# 15 "/usr/include/boost/bind/mem_fn_cc.hpp" 3 4
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);
}
# 269 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
# 311 "/usr/include/boost/bind/mem_fn.hpp" 3 4
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);
}

}
# 23 "/usr/include/boost/mem_fn.hpp" 2 3 4
# 19 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/enum.hpp" 1 3 4
# 21 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/enum_params.hpp" 1 3 4
# 22 "/usr/include/boost/function/detail/prologue.hpp" 2 3 4
# 25 "/usr/include/boost/function.hpp" 2 3 4
# 64 "/usr/include/boost/function.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 13 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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)();
        }
      };
# 230 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 400 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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());
        }
# 562 "/usr/include/boost/function/function_template.hpp" 3 4
        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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 0;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function0& operator=(const function0& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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
                          >& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 14 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 18 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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<std::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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function1& operator=(const function1& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 19 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 23 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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<std::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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function2& operator=(const function2& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 24 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 28 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 3;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function3& operator=(const function3& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 29 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 33 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 4;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function4& operator=(const function4& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 34 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 38 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 5;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function5& operator=(const function5& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 39 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 43 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 6;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function6& operator=(const function6& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 44 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 48 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 7;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function7& operator=(const function7& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 49 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 53 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 8;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function8& operator=(const function8& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 54 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 58 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 9;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function9& operator=(const function9& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 59 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 63 "/usr/include/boost/function/detail/maybe_include.hpp" 3 4
# 1 "/usr/include/boost/function/function_template.hpp" 1 3 4
# 81 "/usr/include/boost/function/function_template.hpp" 3 4
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;
      };
# 326 "/usr/include/boost/function/function_template.hpp" 3 4
      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;
        };
      };
# 475 "/usr/include/boost/function/function_template.hpp" 3 4
      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
# 664 "/usr/include/boost/function/function_template.hpp" 3 4
  {
  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<std::size_t>(0x01));
    }

    struct clear_type {};

  public:
    static const int args = 10;


    template<typename Args>
    struct sig
    {
      typedef result_type type;
    };
# 702 "/usr/include/boost/function/function_template.hpp" 3 4
    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);
    }
# 759 "/usr/include/boost/function/function_template.hpp" 3 4
    ~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;
    }
# 825 "/usr/include/boost/function/function_template.hpp" 3 4
    function10& operator=(const function10& f)
    {
      if (&f == this)
        return *this;

      this->clear();
      { try {
        this->assign_to_own(f);
      } catch(...) {
        vtable = 0;
        throw;;
      }
      }
      return *this;
    }
# 861 "/usr/include/boost/function/function_template.hpp" 3 4
    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>& );
# 1046 "/usr/include/boost/function/function_template.hpp" 3 4
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;
  }
# 1113 "/usr/include/boost/function/function_template.hpp" 3 4
  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;
  }
# 1149 "/usr/include/boost/function/function_template.hpp" 3 4
};




}
# 64 "/usr/include/boost/function/detail/maybe_include.hpp" 2 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 65 "/usr/include/boost/function.hpp" 2 3 4
# 19 "/usr/include/boost/algorithm/string/detail/find_iterator.hpp" 2 3 4

namespace boost {
    namespace algorithm {
        namespace detail {




            template<typename IteratorT>
            class find_iterator_base
            {
            protected:

                typedef IteratorT input_iterator_type;
                typedef iterator_range<IteratorT> match_type;
                typedef function2<
                    match_type,
                    input_iterator_type,
                    input_iterator_type> finder_type;

            protected:



                find_iterator_base() {};

                find_iterator_base( const find_iterator_base& Other ) :
                    m_Finder(Other.m_Finder) {}


                template<typename FinderT>
                find_iterator_base( FinderT Finder, int ) :
                    m_Finder(Finder) {}


                ~find_iterator_base() {}


                match_type do_find(
                    input_iterator_type Begin,
                    input_iterator_type End ) const
                {
                    if (!m_Finder.empty())
                    {
                        return m_Finder(Begin,End);
                    }
                    else
                    {
                        return match_type(End,End);
                    }
                }


                bool is_null() const
                {
                    return m_Finder.empty();
                }

            private:

                finder_type m_Finder;
            };

       }
    }
}
# 25 "/usr/include/boost/algorithm/string/find_iterator.hpp" 2 3 4
# 33 "/usr/include/boost/algorithm/string/find_iterator.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/usr/include/boost/algorithm/string/find_iterator.hpp" 3 4
        template<typename IteratorT>
        class find_iterator :
            public iterator_facade<
                find_iterator<IteratorT>,
                const iterator_range<IteratorT>,
                forward_traversal_tag >,
            private detail::find_iterator_base<IteratorT>
        {
        private:

            friend class ::boost::iterator_core_access;

        private:


            typedef detail::find_iterator_base<IteratorT> base_type;
            typedef typename
                base_type::input_iterator_type input_iterator_type;
            typedef typename
                base_type::match_type match_type;

        public:






            find_iterator() {}





            find_iterator( const find_iterator& Other ) :
                base_type(Other),
                m_Match(Other.m_Match),
                m_End(Other.m_End) {}






            template<typename FinderT>
            find_iterator(
                    IteratorT Begin,
                    IteratorT End,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0),
                m_Match(Begin,Begin),
                m_End(End)
            {
                increment();
            }






            template<typename FinderT, typename RangeT>
            find_iterator(
                    RangeT& Col,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0)
            {
                iterator_range<typename range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
                m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
                m_End=::boost::end(lit_col);

                increment();
            }

        private:



            const match_type& dereference() const
            {
                return m_Match;
            }


            void increment()
            {
                if(m_Match.begin() == m_Match.end())
                    m_Match=this->do_find(m_Match.end(),m_End);
                else
                    m_Match=this->do_find(m_Match.begin()+1,m_End);
            }


            bool equal( const find_iterator& Other ) const
            {
                bool bEof=eof();
                bool bOtherEof=Other.eof();

                return bEof || bOtherEof ? bEof==bOtherEof :
                    (
                        m_Match==Other.m_Match &&
                        m_End==Other.m_End
                    );
            }

        public:
# 163 "/usr/include/boost/algorithm/string/find_iterator.hpp" 3 4
            bool eof() const
            {
                return
                    this->is_null() ||
                    (
                        m_Match.begin() == m_End &&
                        m_Match.end() == m_End
                    );
            }

        private:

            match_type m_Match;
            input_iterator_type m_End;
        };





        template<typename RangeT, typename FinderT>
        inline find_iterator<
            typename range_iterator<RangeT>::type>
        make_find_iterator(
            RangeT& Collection,
            FinderT Finder)
        {
            return find_iterator<typename range_iterator<RangeT>::type>(
                Collection, Finder);
        }
# 208 "/usr/include/boost/algorithm/string/find_iterator.hpp" 3 4
        template<typename IteratorT>
        class split_iterator :
            public iterator_facade<
                split_iterator<IteratorT>,
                const iterator_range<IteratorT>,
                forward_traversal_tag >,
            private detail::find_iterator_base<IteratorT>
        {
        private:

            friend class ::boost::iterator_core_access;

        private:


            typedef detail::find_iterator_base<IteratorT> base_type;
            typedef typename
                base_type::input_iterator_type input_iterator_type;
            typedef typename
                base_type::match_type match_type;

        public:






            split_iterator() {}




            split_iterator( const split_iterator& Other ) :
                base_type(Other),
                m_Match(Other.m_Match),
                m_Next(Other.m_Next),
                m_End(Other.m_End),
                m_bEof(Other.m_bEof)
            {}






            template<typename FinderT>
            split_iterator(
                    IteratorT Begin,
                    IteratorT End,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0),
                m_Match(Begin,Begin),
                m_Next(Begin),
                m_End(End),
                m_bEof(false)
            {

                if(Begin!=End)
                {
                    increment();
                }
            }





            template<typename FinderT, typename RangeT>
            split_iterator(
                    RangeT& Col,
                    FinderT Finder ) :
                detail::find_iterator_base<IteratorT>(Finder,0),
                m_bEof(false)
            {
                iterator_range<typename range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
                m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
                m_Next=::boost::begin(lit_col);
                m_End=::boost::end(lit_col);


                if(m_Next!=m_End)
                {
                    increment();
                }
            }


        private:



            const match_type& dereference() const
            {
                return m_Match;
            }


            void increment()
            {
                match_type FindMatch=this->do_find( m_Next, m_End );

                if(FindMatch.begin()==m_End && FindMatch.end()==m_End)
                {
                    if(m_Match.end()==m_End)
                    {

                        m_bEof=true;
                    }
                }

                m_Match=match_type( m_Next, FindMatch.begin() );
                m_Next=FindMatch.end();
            }


            bool equal( const split_iterator& Other ) const
            {
                bool bEof=eof();
                bool bOtherEof=Other.eof();

                return bEof || bOtherEof ? bEof==bOtherEof :
                    (
                        m_Match==Other.m_Match &&
                        m_Next==Other.m_Next &&
                        m_End==Other.m_End
                    );
            }

        public:
# 346 "/usr/include/boost/algorithm/string/find_iterator.hpp" 3 4
            bool eof() const
            {
                return this->is_null() || m_bEof;
            }

        private:

            match_type m_Match;
            input_iterator_type m_Next;
            input_iterator_type m_End;
            bool m_bEof;
        };





        template<typename RangeT, typename FinderT>
        inline split_iterator<
            typename range_iterator<RangeT>::type>
        make_split_iterator(
            RangeT& Collection,
            FinderT Finder)
        {
            return split_iterator<typename range_iterator<RangeT>::type>(
                Collection, Finder);
        }


    }


    using algorithm::find_iterator;
    using algorithm::make_find_iterator;
    using algorithm::split_iterator;
    using algorithm::make_split_iterator;

}
# 28 "/usr/include/boost/algorithm/string/iter_find.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/detail/util.hpp" 1 3 4
# 18 "/usr/include/boost/algorithm/string/detail/util.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {
# 31 "/usr/include/boost/algorithm/string/detail/util.hpp" 3 4
            template< typename CharT >
            struct empty_container
            {
                typedef empty_container<CharT> type;
                typedef CharT value_type;
                typedef std::size_t size_type;
                typedef std::ptrdiff_t difference_type;
                typedef const value_type& reference;
                typedef const value_type& const_reference;
                typedef const value_type* iterator;
                typedef const value_type* const_iterator;



                const_iterator begin() const
                {
                    return reinterpret_cast<const_iterator>(0);
                }

                const_iterator end() const
                {
                    return reinterpret_cast<const_iterator>(0);
                }

                bool empty() const
                {
                    return false;
                }

                size_type size() const
                {
                    return 0;
                }
            };




            template<typename InputIteratorT, typename OutputIteratorT>
            inline OutputIteratorT bounded_copy(
                InputIteratorT First,
                InputIteratorT Last,
                OutputIteratorT DestFirst,
                OutputIteratorT DestLast )
            {
                InputIteratorT InputIt=First;
                OutputIteratorT OutputIt=DestFirst;
                for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
                {
                    *OutputIt=*InputIt;
                }

                return OutputIt;
            }




            template<
                typename SeqT,
                typename IteratorT=typename SeqT::const_iterator >
            struct copy_iterator_rangeF :
                public std::unary_function< iterator_range<IteratorT>, SeqT >
            {
                SeqT operator()( const iterator_range<IteratorT>& Range ) const
                {
                    return copy_range<SeqT>(Range);
                }
            };

        }
    }
}
# 29 "/usr/include/boost/algorithm/string/iter_find.hpp" 2 3 4
# 41 "/usr/include/boost/algorithm/string/iter_find.hpp" 3 4
namespace boost {
    namespace algorithm {
# 67 "/usr/include/boost/algorithm/string/iter_find.hpp" 3 4
        template<
            typename SequenceSequenceT,
            typename RangeT,
            typename FinderT >
        inline SequenceSequenceT&
        iter_find(
            SequenceSequenceT& Result,
            RangeT& Input,
            FinderT Finder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_iterator<RangeT>::type> )>::failed> boost_concept_check81



                  ;

            iterator_range<typename range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            typedef typename
                range_iterator<RangeT>::type input_iterator_type;
            typedef find_iterator<input_iterator_type> find_iterator_type;
            typedef detail::copy_iterator_rangeF<
                typename
                    range_value<SequenceSequenceT>::type,
                input_iterator_type> copy_range_type;

            input_iterator_type InputEnd=::boost::end(lit_input);

            typedef transform_iterator<copy_range_type, find_iterator_type>
                transform_iter_type;

            transform_iter_type itBegin=
                ::boost::make_transform_iterator(
                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                    copy_range_type());

            transform_iter_type itEnd=
                ::boost::make_transform_iterator(
                    find_iterator_type(),
                    copy_range_type());

            SequenceSequenceT Tmp(itBegin, itEnd);

            Result.swap(Tmp);
            return Result;
        }
# 138 "/usr/include/boost/algorithm/string/iter_find.hpp" 3 4
        template<
            typename SequenceSequenceT,
            typename RangeT,
            typename FinderT >
        inline SequenceSequenceT&
        iter_split(
            SequenceSequenceT& Result,
            RangeT& Input,
            FinderT Finder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept<FinderT, typename range_iterator<RangeT>::type> )>::failed> boost_concept_check151


                  ;

            iterator_range<typename range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            typedef typename
                range_iterator<RangeT>::type input_iterator_type;
            typedef split_iterator<input_iterator_type> find_iterator_type;
            typedef detail::copy_iterator_rangeF<
                typename
                    range_value<SequenceSequenceT>::type,
                input_iterator_type> copy_range_type;

            input_iterator_type InputEnd=::boost::end(lit_input);

            typedef transform_iterator<copy_range_type, find_iterator_type>
                transform_iter_type;

            transform_iter_type itBegin=
                ::boost::make_transform_iterator(
                    find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
                    copy_range_type() );

            transform_iter_type itEnd=
                ::boost::make_transform_iterator(
                    find_iterator_type(),
                    copy_range_type() );

            SequenceSequenceT Tmp(itBegin, itEnd);

            Result.swap(Tmp);
            return Result;
        }

    }


    using algorithm::iter_find;
    using algorithm::iter_split;

}
# 17 "/usr/include/boost/algorithm/string/split.hpp" 2 3 4
# 34 "/usr/include/boost/algorithm/string/split.hpp" 3 4
namespace boost {
    namespace algorithm {
# 61 "/usr/include/boost/algorithm/string/split.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& find_all(
            SequenceSequenceT& Result,
            Range1T& Input,
            const Range2T& Search)
        {
            return ::boost::algorithm::iter_find(
                Result,
                Input,
                ::boost::algorithm::first_finder(Search) );
        }
# 96 "/usr/include/boost/algorithm/string/split.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T, typename Range2T >
        inline SequenceSequenceT& ifind_all(
            SequenceSequenceT& Result,
            Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::iter_find(
                Result,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );
        }
# 139 "/usr/include/boost/algorithm/string/split.hpp" 3 4
        template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
        inline SequenceSequenceT& split(
            SequenceSequenceT& Result,
            RangeT& Input,
            PredicateT Pred,
            token_compress_mode_type eCompress=token_compress_off )
        {
            return ::boost::algorithm::iter_split(
                Result,
                Input,
                ::boost::algorithm::token_finder( Pred, eCompress ) );
        }

    }


    using algorithm::find_all;
    using algorithm::ifind_all;
    using algorithm::split;

}
# 24 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/join.hpp" 1 3 4
# 15 "/usr/include/boost/algorithm/string/join.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/detail/sequence.hpp" 1 3 4
# 22 "/usr/include/boost/algorithm/string/detail/sequence.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template< typename InputT, typename ForwardIteratorT >
            inline void insert(
                InputT& Input,
                typename InputT::iterator At,
                ForwardIteratorT Begin,
                ForwardIteratorT End )
            {
                Input.insert( At, Begin, End );
            }

            template< typename InputT, typename InsertT >
            inline void insert(
                InputT& Input,
                typename InputT::iterator At,
                const InsertT& Insert )
            {
                ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
            }







            template< typename InputT >
            inline typename InputT::iterator erase(
                InputT& Input,
                typename InputT::iterator From,
                typename InputT::iterator To )
            {
                return Input.erase( From, To );
            }





            template< bool HasConstTimeOperations >
            struct replace_const_time_helper
            {
                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {

                    ForwardIteratorT InsertIt=Begin;
                    typename InputT::iterator InputIt=From;
                    for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ )
                    {
                        *InputIt=*InsertIt;
                    }

                    if ( InsertIt!=End )
                    {

                        Input.insert( InputIt, InsertIt, End );
                    }
                    else
                    {
                        if ( InputIt!=To )
                        {

                            Input.erase( InputIt, To );
                        }
                    }
                }
            };

            template<>
            struct replace_const_time_helper< true >
            {

                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {
                    typename InputT::iterator At=Input.erase( From, To );
                    if ( Begin!=End )
                    {
                        if(!Input.empty())
                        {
                            Input.insert( At, Begin, End );
                        }
                        else
                        {
                            Input.insert( Input.begin(), Begin, End );
                        }
                    }
                }
            };


            template< bool HasNative >
            struct replace_native_helper
            {
                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {
                    replace_const_time_helper<
                        boost::mpl::and_<
                            has_const_time_insert<InputT>,
                            has_const_time_erase<InputT> >::value >()(
                        Input, From, To, Begin, End );
                }
            };


            template<>
            struct replace_native_helper< true >
            {
                template< typename InputT, typename ForwardIteratorT >
                void operator()(
                    InputT& Input,
                    typename InputT::iterator From,
                    typename InputT::iterator To,
                    ForwardIteratorT Begin,
                    ForwardIteratorT End )
                {
                    Input.replace( From, To, Begin, End );
                }
            };



            template< typename InputT, typename ForwardIteratorT >
            inline void replace(
                InputT& Input,
                typename InputT::iterator From,
                typename InputT::iterator To,
                ForwardIteratorT Begin,
                ForwardIteratorT End )
            {
                replace_native_helper< has_native_replace<InputT>::value >()(
                    Input, From, To, Begin, End );
            }

            template< typename InputT, typename InsertT >
            inline void replace(
                InputT& Input,
                typename InputT::iterator From,
                typename InputT::iterator To,
                const InsertT& Insert )
            {
                if(From!=To)
                {
                    ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
                }
                else
                {
                    ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
                }
            }

        }
    }
}
# 16 "/usr/include/boost/algorithm/string/join.hpp" 2 3 4
# 28 "/usr/include/boost/algorithm/string/join.hpp" 3 4
namespace boost {
    namespace algorithm {
# 44 "/usr/include/boost/algorithm/string/join.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T>
        inline typename range_value<SequenceSequenceT>::type
        join(
            const SequenceSequenceT& Input,
            const Range1T& Separator)
        {

            typedef typename range_value<SequenceSequenceT>::type ResultT;
            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;


            InputIteratorT itBegin=::boost::begin(Input);
            InputIteratorT itEnd=::boost::end(Input);


            ResultT Result;


            if(itBegin!=itEnd)
            {
                detail::insert(Result, ::boost::end(Result), *itBegin);
                ++itBegin;
            }

            for(;itBegin!=itEnd; ++itBegin)
            {

                detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));

                detail::insert(Result, ::boost::end(Result), *itBegin);
            }

            return Result;
        }
# 94 "/usr/include/boost/algorithm/string/join.hpp" 3 4
        template< typename SequenceSequenceT, typename Range1T, typename PredicateT>
        inline typename range_value<SequenceSequenceT>::type
        join_if(
            const SequenceSequenceT& Input,
            const Range1T& Separator,
            PredicateT Pred)
        {

            typedef typename range_value<SequenceSequenceT>::type ResultT;
            typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;


            InputIteratorT itBegin=::boost::begin(Input);
            InputIteratorT itEnd=::boost::end(Input);


            ResultT Result;


            while(itBegin!=itEnd && !Pred(*itBegin)) ++itBegin;

            if(itBegin!=itEnd)
            {
                detail::insert(Result, ::boost::end(Result), *itBegin);
                ++itBegin;
            }

            for(;itBegin!=itEnd; ++itBegin)
            {
                if(Pred(*itBegin))
                {

                    detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));

                    detail::insert(Result, ::boost::end(Result), *itBegin);
                }
            }

            return Result;
        }

    }


    using algorithm::join;
    using algorithm::join_if;

}
# 25 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/replace.hpp" 1 3 4
# 22 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/find_format.hpp" 1 3 4
# 23 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 1 3 4
# 18 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/detail/find_format_store.hpp" 1 3 4
# 17 "/usr/include/boost/algorithm/string/detail/find_format_store.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {







            template<
                typename ForwardIteratorT,
                typename FormatterT,
                typename FormatResultT >
            class find_format_store :
                public iterator_range<ForwardIteratorT>
            {
            public:

                typedef iterator_range<ForwardIteratorT> base_type;
                typedef FormatterT formatter_type;
                typedef FormatResultT format_result_type;

            public:

                find_format_store(
                        const base_type& FindResult,
                        const format_result_type& FormatResult,
                        const formatter_type& Formatter ) :
                    base_type(FindResult),
                    m_FormatResult(FormatResult),
                    m_Formatter(Formatter) {}


                template< typename FindResultT >
                find_format_store& operator=( FindResultT FindResult )
                {
                    iterator_range<ForwardIteratorT>::operator=(FindResult);
                    if( !this->empty() ) {
                        m_FormatResult=m_Formatter(FindResult);
                    }

                    return *this;
                }


                const format_result_type& format_result()
                {
                    return m_FormatResult;
                }

            private:
                format_result_type m_FormatResult;
                const formatter_type& m_Formatter;
            };

            template<typename InputT, typename FindResultT>
            bool check_find_result(InputT&, FindResultT& FindResult)
            {
                typedef typename
                    range_const_iterator<InputT>::type input_iterator_type;
                iterator_range<input_iterator_type> ResultRange(FindResult);
                return !ResultRange.empty();
            }




        }
    }
}
# 19 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/detail/replace_storage.hpp" 1 3 4
# 20 "/usr/include/boost/algorithm/string/detail/replace_storage.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



            template< typename StorageT, typename OutputIteratorT >
            inline OutputIteratorT move_from_storage(
                StorageT& Storage,
                OutputIteratorT DestBegin,
                OutputIteratorT DestEnd )
            {
                OutputIteratorT OutputIt=DestBegin;

                while( !Storage.empty() && OutputIt!=DestEnd )
                {
                    *OutputIt=Storage.front();
                    Storage.pop_front();
                    ++OutputIt;
                }

                return OutputIt;
            }

            template< typename StorageT, typename WhatT >
            inline void copy_to_storage(
                StorageT& Storage,
                const WhatT& What )
            {
                Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
            }




            template< bool HasStableIterators >
            struct process_segment_helper
            {

                template<
                    typename StorageT,
                    typename InputT,
                    typename ForwardIteratorT >
                ForwardIteratorT operator()(
                    StorageT& Storage,
                    InputT& ,
                    ForwardIteratorT InsertIt,
                    ForwardIteratorT SegmentBegin,
                    ForwardIteratorT SegmentEnd )
                {

                    ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );






                    if( Storage.empty() )
                    {
                        if( It==SegmentBegin )
                        {

                            return SegmentEnd;
                        }
                        else
                        {

                            return std::copy( SegmentBegin, SegmentEnd, It );
                        }
                    }
                    else
                    {

                        while( It!=SegmentEnd )
                        {

                            Storage.push_back( *It );

                            *It=Storage.front();
                            Storage.pop_front();


                            ++It;
                        }

                        return It;
                    }
                }
            };

            template<>
            struct process_segment_helper< true >
            {

                template<
                    typename StorageT,
                    typename InputT,
                    typename ForwardIteratorT >
                ForwardIteratorT operator()(
                    StorageT& Storage,
                    InputT& Input,
                    ForwardIteratorT InsertIt,
                    ForwardIteratorT SegmentBegin,
                    ForwardIteratorT SegmentEnd )

                {

                    ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );

                    Storage.clear();

                    return SegmentEnd;
                }
            };


            template<
                typename StorageT,
                typename InputT,
                typename ForwardIteratorT >
            inline ForwardIteratorT process_segment(
                StorageT& Storage,
                InputT& Input,
                ForwardIteratorT InsertIt,
                ForwardIteratorT SegmentBegin,
                ForwardIteratorT SegmentEnd )
            {
                return
                    process_segment_helper<
                        has_stable_iterators<InputT>::value>()(
                                Storage, Input, InsertIt, SegmentBegin, SegmentEnd );
            }


        }
    }
}
# 20 "/usr/include/boost/algorithm/string/detail/find_format.hpp" 2 3 4

namespace boost {
    namespace algorithm {
        namespace detail {



           template<
                typename OutputIteratorT,
                typename InputT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline OutputIteratorT find_format_copy_impl2(
                OutputIteratorT Output,
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult )
            {
                typedef find_format_store<
                    typename
                        range_const_iterator<InputT>::type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );

                if ( !M )
                {

                    Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                    return Output;
                }


                Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );


                Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );

                Output = std::copy( M.end(), ::boost::end(Input), Output );

                return Output;
            }

            template<
                typename OutputIteratorT,
                typename InputT,
                typename FormatterT,
                typename FindResultT >
            inline OutputIteratorT find_format_copy_impl(
                OutputIteratorT Output,
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult )
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_copy_impl2(
                        Output,
                        Input,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                }
            }




           template<
                typename InputT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline InputT find_format_copy_impl2(
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult)
            {
                typedef find_format_store<
                    typename
                        range_const_iterator<InputT>::type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );

                if ( !M )
                {

                    return InputT( Input );
                }

                InputT Output;

                boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );

                boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );

                boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );

                return Output;
            }

            template<
                typename InputT,
                typename FormatterT,
                typename FindResultT >
            inline InputT find_format_copy_impl(
                const InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_copy_impl2(
                        Input,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return Input;
                }
            }



            template<
                typename InputT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline void find_format_impl2(
                InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult)
            {
                typedef find_format_store<
                    typename
                        range_iterator<InputT>::type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );

                if ( !M )
                {

                    return;
                }


                ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
            }

            template<
                typename InputT,
                typename FormatterT,
                typename FindResultT >
            inline void find_format_impl(
                InputT& Input,
                FormatterT Formatter,
                const FindResultT& FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    ::boost::algorithm::detail::find_format_impl2(
                        Input,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                }
            }

        }
    }
}
# 24 "/usr/include/boost/algorithm/string/find_format.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/detail/find_format_all.hpp" 1 3 4
# 21 "/usr/include/boost/algorithm/string/detail/find_format_all.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {



           template<
                typename OutputIteratorT,
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline OutputIteratorT find_format_all_copy_impl2(
                OutputIteratorT Output,
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult )
            {
                typedef typename
                    range_const_iterator<InputT>::type input_iterator_type;

                typedef find_format_store<
                        input_iterator_type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );


                input_iterator_type LastMatch=::boost::begin(Input);


                while( M )
                {

                    Output = std::copy( LastMatch, M.begin(), Output );

                    Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );


                    LastMatch=M.end();
                    M=Finder( LastMatch, ::boost::end(Input) );
                }


                Output = std::copy( LastMatch, ::boost::end(Input), Output );

                return Output;
            }

            template<
                typename OutputIteratorT,
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT >
            inline OutputIteratorT find_format_all_copy_impl(
                OutputIteratorT Output,
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult )
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
                        Output,
                        Input,
                        Finder,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
                }
            }



           template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline InputT find_format_all_copy_impl2(
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult,
                const FormatResultT& FormatResult)
            {
                typedef typename
                    range_const_iterator<InputT>::type input_iterator_type;

                typedef find_format_store<
                        input_iterator_type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );


                input_iterator_type LastMatch=::boost::begin(Input);


                InputT Output;


                while( M )
                {

                    boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() );

                    boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );


                    LastMatch=M.end();
                    M=Finder( LastMatch, ::boost::end(Input) );
                }


                ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );

                return Output;
            }

            template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT >
            inline InputT find_format_all_copy_impl(
                const InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                const FindResultT& FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    return ::boost::algorithm::detail::find_format_all_copy_impl2(
                        Input,
                        Finder,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                } else {
                    return Input;
                }
            }



            template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT,
                typename FormatResultT >
            inline void find_format_all_impl2(
                InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                FindResultT FindResult,
                FormatResultT FormatResult)
            {
                typedef typename
                    range_iterator<InputT>::type input_iterator_type;
                typedef find_format_store<
                        input_iterator_type,
                        FormatterT,
                        FormatResultT > store_type;


                store_type M( FindResult, FormatResult, Formatter );


                std::deque<
                    typename range_value<InputT>::type> Storage;


                input_iterator_type InsertIt=::boost::begin(Input);
                input_iterator_type SearchIt=::boost::begin(Input);

                while( M )
                {

                    InsertIt=process_segment(
                        Storage,
                        Input,
                        InsertIt,
                        SearchIt,
                        M.begin() );


                    SearchIt=M.end();


                    ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );


                    M=Finder( SearchIt, ::boost::end(Input) );
                }


                InsertIt=::boost::algorithm::detail::process_segment(
                    Storage,
                    Input,
                    InsertIt,
                    SearchIt,
                    ::boost::end(Input) );

                if ( Storage.empty() )
                {

                    ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
                }
                else
                {

                    ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
                }
            }

            template<
                typename InputT,
                typename FinderT,
                typename FormatterT,
                typename FindResultT >
            inline void find_format_all_impl(
                InputT& Input,
                FinderT Finder,
                FormatterT Formatter,
                FindResultT FindResult)
            {
                if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
                    ::boost::algorithm::detail::find_format_all_impl2(
                        Input,
                        Finder,
                        Formatter,
                        FindResult,
                        Formatter(FindResult) );
                }
            }

        }
    }
}
# 25 "/usr/include/boost/algorithm/string/find_format.hpp" 2 3 4







namespace boost {
    namespace algorithm {
# 53 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT,
            typename FinderT,
            typename FormatterT>
        inline OutputIteratorT find_format_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check69



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check74



                  ;

            iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            return detail::find_format_copy_impl(
                Output,
                lit_input,
                Formatter,
                Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
        }





        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT>
        inline SequenceT find_format_copy(
            const SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check103



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check108



                  ;

            return detail::find_format_copy_impl(
                Input,
                Formatter,
                Finder(::boost::begin(Input), ::boost::end(Input)));
        }
# 125 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT>
        inline void find_format(
            SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter)
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check139



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check144



                  ;

            detail::find_format_impl(
                Input,
                Formatter,
                Finder(::boost::begin(Input), ::boost::end(Input)));
        }
# 172 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT,
            typename FinderT,
            typename FormatterT>
        inline OutputIteratorT find_format_all_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            FinderT Finder,
            FormatterT Formatter)
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check188



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<RangeT>::type> )>::failed> boost_concept_check193



                  ;

            iterator_range<typename range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));

            return detail::find_format_all_copy_impl(
                Output,
                lit_input,
                Finder,
                Formatter,
                Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
        }





        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT >
        inline SequenceT find_format_all_copy(
            const SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check223



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check228



                  ;

            return detail::find_format_all_copy_impl(
                Input,
                Finder,
                Formatter,
                Finder( ::boost::begin(Input), ::boost::end(Input) ) );
        }
# 247 "/usr/include/boost/algorithm/string/find_format.hpp" 3 4
        template<
            typename SequenceT,
            typename FinderT,
            typename FormatterT >
        inline void find_format_all(
            SequenceT& Input,
            FinderT Finder,
            FormatterT Formatter )
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FinderConcept< FinderT, typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check261



                  ;
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( FormatterConcept< FormatterT, FinderT,typename range_const_iterator<SequenceT>::type> )>::failed> boost_concept_check266



                  ;

            detail::find_format_all_impl(
                Input,
                Finder,
                Formatter,
                Finder(::boost::begin(Input), ::boost::end(Input)));

        }

    }


    using algorithm::find_format_copy;
    using algorithm::find_format;
    using algorithm::find_format_all_copy;
    using algorithm::find_format_all;

}
# 23 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4

# 1 "/usr/include/boost/algorithm/string/formatter.hpp" 1 3 4
# 19 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
# 1 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 1 3 4
# 24 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 3 4
namespace boost {
    namespace algorithm {
        namespace detail {




            template<typename RangeT>
            struct const_formatF
            {
            private:
                typedef typename
                    range_const_iterator<RangeT>::type format_iterator;
                typedef iterator_range<format_iterator> result_type;

            public:

                const_formatF(const RangeT& Format) :
                    m_Format(::boost::begin(Format), ::boost::end(Format)) {}
# 53 "/usr/include/boost/algorithm/string/detail/formatter.hpp" 3 4
                template<typename Range2T>
                const result_type& operator()(const Range2T&) const
                {
                    return m_Format;
                }

            private:
                result_type m_Format;
            };




            template<typename RangeT>
            struct identity_formatF
            {

                template< typename Range2T >
                const RangeT& operator()(const Range2T& Replace) const
                {
                    return RangeT(::boost::begin(Replace), ::boost::end(Replace));
                }
            };




            template< typename CharT >
            struct empty_formatF
            {
                template< typename ReplaceT >
                empty_container<CharT> operator()(const ReplaceT&) const
                {
                    return empty_container<CharT>();
                }
            };




            template<typename FinderT>
            struct dissect_formatF
            {
            public:

                dissect_formatF(FinderT Finder) :
                  m_Finder(Finder) {}


                  template<typename RangeT>
                  inline iterator_range<
                      typename range_const_iterator<RangeT>::type>
                  operator()(const RangeT& Replace) const
                  {
                      return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
                  }

            private:
                FinderT m_Finder;
            };


        }
    }
}
# 20 "/usr/include/boost/algorithm/string/formatter.hpp" 2 3 4
# 32 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
namespace boost {
    namespace algorithm {
# 45 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename RangeT>
        inline detail::const_formatF<
            iterator_range<
                typename range_const_iterator<RangeT>::type> >
        const_formatter(const RangeT& Format)
        {
            return detail::const_formatF<
                iterator_range<
                    typename range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
        }
# 63 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename RangeT>
        inline detail::identity_formatF<
            iterator_range<
                typename range_const_iterator<RangeT>::type> >
        identity_formatter()
        {
            return detail::identity_formatF<
                iterator_range<
                    typename range_const_iterator<RangeT>::type> >();
        }
# 83 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename RangeT>
        inline detail::empty_formatF<
            typename range_value<RangeT>::type>
        empty_formatter(const RangeT&)
        {
            return detail::empty_formatF<
                typename range_value<RangeT>::type>();
        }
# 101 "/usr/include/boost/algorithm/string/formatter.hpp" 3 4
        template<typename FinderT>
        inline detail::dissect_formatF< FinderT >
        dissect_formatter(const FinderT& Finder)
        {
            return detail::dissect_formatF<FinderT>(Finder);
        }


    }


    using algorithm::const_formatter;
    using algorithm::identity_formatter;
    using algorithm::empty_formatter;
    using algorithm::dissect_formatter;

}
# 25 "/usr/include/boost/algorithm/string/replace.hpp" 2 3 4







namespace boost {
    namespace algorithm {
# 52 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT replace_range_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const iterator_range<
                typename
                    range_const_iterator<Range1T>::type>& SearchRange,
            const Range2T& Format)
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::const_formatter(Format));
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT replace_range_copy(
            const SequenceT& Input,
            const iterator_range<
                typename
                    range_const_iterator<SequenceT>::type>& SearchRange,
            const RangeT& Format)
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::const_formatter(Format));
        }
# 98 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void replace_range(
            SequenceT& Input,
            const iterator_range<
                typename
                    range_iterator<SequenceT>::type>& SearchRange,
            const RangeT& Format)
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::const_formatter(Format));
        }
# 130 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format)
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_first_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 173 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_first(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 205 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range2T, typename Range1T>
        inline SequenceT ireplace_first_copy(
            const SequenceT& Input,
            const Range2T& Search,
            const Range1T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 252 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_first(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 283 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_last_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 326 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_last(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 358 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT ireplace_last_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 406 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_last(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 439 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth,
            const Range3T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_nth_copy(
            const SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::const_formatter(Format) );
        }
# 486 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_nth(
            SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::const_formatter(Format) );
        }
# 521 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT ireplace_nth_copy(
            const SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 572 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_nth(
            SequenceT& Input,
            const Range1T& Search,
            int Nth,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 604 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT replace_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT replace_all_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 648 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void replace_all(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::const_formatter(Format) );
        }
# 680 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T,
            typename Range3T>
        inline OutputIteratorT ireplace_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const Range3T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename Range1T, typename Range2T>
        inline SequenceT ireplace_all_copy(
            const SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 727 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename Range1T, typename Range2T>
        inline void ireplace_all(
            SequenceT& Input,
            const Range1T& Search,
            const Range2T& Format,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::const_formatter(Format) );
        }
# 762 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT replace_head_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            int N,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT replace_head_copy(
            const SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }
# 808 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void replace_head(
            SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }
# 842 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT replace_tail_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            int N,
            const Range2T& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT replace_tail_copy(
            const SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }
# 888 "/usr/include/boost/algorithm/string/replace.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void replace_tail(
            SequenceT& Input,
            int N,
            const RangeT& Format )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::const_formatter(Format) );
        }

    }


    using algorithm::replace_range_copy;
    using algorithm::replace_range;
    using algorithm::replace_first_copy;
    using algorithm::replace_first;
    using algorithm::ireplace_first_copy;
    using algorithm::ireplace_first;
    using algorithm::replace_last_copy;
    using algorithm::replace_last;
    using algorithm::ireplace_last_copy;
    using algorithm::ireplace_last;
    using algorithm::replace_nth_copy;
    using algorithm::replace_nth;
    using algorithm::ireplace_nth_copy;
    using algorithm::ireplace_nth;
    using algorithm::replace_all_copy;
    using algorithm::replace_all;
    using algorithm::ireplace_all_copy;
    using algorithm::ireplace_all;
    using algorithm::replace_head_copy;
    using algorithm::replace_head;
    using algorithm::replace_tail_copy;
    using algorithm::replace_tail;

}
# 26 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 1 "/usr/include/boost/algorithm/string/erase.hpp" 1 3 4
# 31 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
namespace boost {
    namespace algorithm {
# 49 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename OutputIteratorT, typename RangeT>
        inline OutputIteratorT erase_range_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            const iterator_range<
                typename
                    range_const_iterator<RangeT>::type>& SearchRange )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT>
        inline SequenceT erase_range_copy(
            const SequenceT& Input,
            const iterator_range<
                typename
                    range_const_iterator<SequenceT>::type>& SearchRange )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 89 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT>
        inline void erase_range(
            SequenceT& Input,
            const iterator_range<
                typename
                    range_iterator<SequenceT>::type>& SearchRange )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::range_finder(SearchRange),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 118 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_first_copy(
            const SequenceT& Input,
            const RangeT& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 157 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_first(
            SequenceT& Input,
            const RangeT& Search )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 186 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_first_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_first_copy(
            const SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 228 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_first(
            SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 256 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_last_copy(
            const SequenceT& Input,
            const RangeT& Search )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 295 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_last(
            SequenceT& Input,
            const RangeT& Search )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 324 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_last_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_last_copy(
            const SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 366 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_last(
            SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 397 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_nth_copy(
            const SequenceT& Input,
            const RangeT& Search,
            int Nth )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 440 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_nth(
            SequenceT& Input,
            const RangeT& Search,
            int Nth )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 472 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_nth_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            int Nth,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_nth_copy(
            const SequenceT& Input,
            const RangeT& Search,
            int Nth,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                empty_formatter(Input) );
        }
# 518 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_nth(
            SequenceT& Input,
            const RangeT& Search,
            int Nth,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 549 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT erase_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT erase_all_copy(
            const SequenceT& Input,
            const RangeT& Search )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 588 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void erase_all(
            SequenceT& Input,
            const RangeT& Search )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 617 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename Range1T,
            typename Range2T>
        inline OutputIteratorT ierase_all_copy(
            OutputIteratorT Output,
            const Range1T& Input,
            const Range2T& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Output,
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }





        template<typename SequenceT, typename RangeT>
        inline SequenceT ierase_all_copy(
            const SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            return ::boost::algorithm::find_format_all_copy(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 659 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT, typename RangeT>
        inline void ierase_all(
            SequenceT& Input,
            const RangeT& Search,
            const std::locale& Loc=std::locale() )
        {
            ::boost::algorithm::find_format_all(
                Input,
                ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
                ::boost::algorithm::empty_formatter(Input) );
        }
# 691 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT>
        inline OutputIteratorT erase_head_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }





        template<typename SequenceT>
        inline SequenceT erase_head_copy(
            const SequenceT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }
# 732 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT>
        inline void erase_head(
            SequenceT& Input,
            int N )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::head_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }
# 763 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<
            typename OutputIteratorT,
            typename RangeT>
        inline OutputIteratorT erase_tail_copy(
            OutputIteratorT Output,
            const RangeT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Output,
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }





        template<typename SequenceT>
        inline SequenceT erase_tail_copy(
            const SequenceT& Input,
            int N )
        {
            return ::boost::algorithm::find_format_copy(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }
# 804 "/usr/include/boost/algorithm/string/erase.hpp" 3 4
        template<typename SequenceT>
        inline void erase_tail(
            SequenceT& Input,
            int N )
        {
            ::boost::algorithm::find_format(
                Input,
                ::boost::algorithm::tail_finder(N),
                ::boost::algorithm::empty_formatter( Input ) );
        }

    }


    using algorithm::erase_range_copy;
    using algorithm::erase_range;
    using algorithm::erase_first_copy;
    using algorithm::erase_first;
    using algorithm::ierase_first_copy;
    using algorithm::ierase_first;
    using algorithm::erase_last_copy;
    using algorithm::erase_last;
    using algorithm::ierase_last_copy;
    using algorithm::ierase_last;
    using algorithm::erase_nth_copy;
    using algorithm::erase_nth;
    using algorithm::ierase_nth_copy;
    using algorithm::ierase_nth;
    using algorithm::erase_all_copy;
    using algorithm::erase_all;
    using algorithm::ierase_all_copy;
    using algorithm::ierase_all;
    using algorithm::erase_head_copy;
    using algorithm::erase_head;
    using algorithm::erase_tail_copy;
    using algorithm::erase_tail;

}
# 27 "/usr/include/boost/algorithm/string.hpp" 2 3 4
# 34 "./drizzled/identifier/catalog.h" 2

namespace drizzled {
namespace identifier {

class Catalog : public Identifier
{
public:
  Catalog(str_ref);
  bool isValid() const;
  bool compare(const std::string &arg) const;

  const std::string &getPath() const
  {
    return path;
  }

  const std::string &getName() const
  {
    return _name;
  }

  const std::string &name() const
  {
    return _name;
  }

  virtual std::string getSQLPath() const
  {
    return _name;
  }

  size_t getHashValue() const
  {
    return hash_value;
  }

  friend bool operator<(const Catalog &left, const Catalog &right)
  {
    return boost::ilexicographical_compare(left.getName(), right.getName());
  }

  friend std::ostream& operator<<(std::ostream& output, const Catalog &identifier)
  {
    return output << "Catalog:(" << identifier.getName() << ", " << identifier.getPath() << ")";
  }

  friend bool operator==(const Catalog &left, const Catalog &right)
  {
    return boost::iequals(left.getName(), right.getName());
  }

  void resetPath()
  {
    init();
  }

private:
  void init();

  std::string _name;
  std::string path;
  size_t hash_value;
};

inline std::size_t hash_value(Catalog const& b)
{
  return b.getHashValue();
}

}
}
# 45 "./drizzled/identifier.h" 2
# 1 "./drizzled/identifier/schema.h" 1
# 32 "./drizzled/identifier/schema.h"
       




namespace drizzled {
namespace identifier {

class __attribute__ ((visibility("default"))) Schema : public Identifier
{
  std::string _corrected_db;
  std::string db;
  std::string db_path;

public:
  Schema(str_ref);

  virtual std::string getSQLPath() const
 {
  return db;
 }

  const std::string &getPath() const;

  const std::string &getSchemaName() const
  {
    return db;
  }

  const std::string &getCompareWithSchemaName() const
  {
    return _corrected_db;
  }

  const std::string &getCatalogName() const;

  virtual bool isValid() const;

  inline virtual bool isSystem() const
  {
    return false;
  }

  bool compare(const std::string &arg) const;
  bool compare(const Schema&) const;

  friend bool operator<(const Schema& left, const Schema& right)
  {
    return boost::ilexicographical_compare(left.getSchemaName(), right.getSchemaName());
  }

  friend bool operator==(const Schema& left, const Schema& right)
  {
    return boost::iequals(left._corrected_db, right._corrected_db);
  }
};

std::ostream& operator<<(std::ostream&, const Schema&);


}
}
# 46 "./drizzled/identifier.h" 2
# 1 "./drizzled/identifier/table.h" 1
# 33 "./drizzled/identifier/table.h"
       



# 1 "./drizzled/message/table.pb.h" 1
# 9 "./drizzled/message/table.pb.h"
# 1 "/usr/include/google/protobuf/stubs/common.h" 1 3 4
# 38 "/usr/include/google/protobuf/stubs/common.h" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 39 "/usr/include/google/protobuf/stubs/common.h" 2 3 4

# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 41 "/usr/include/google/protobuf/stubs/common.h" 2 3 4
# 78 "/usr/include/google/protobuf/stubs/common.h" 3 4
namespace std {}

namespace google {
namespace protobuf {
# 104 "/usr/include/google/protobuf/stubs/common.h" 3 4
namespace internal {
# 120 "/usr/include/google/protobuf/stubs/common.h" 3 4
static const int kMinHeaderVersionForLibrary = 2004000;







static const int kMinHeaderVersionForProtoc = 2004000;



void VerifyVersion(int headerVersion, int minLibraryVersion,
                                      const char* filename);


std::string VersionString(int version);

}
# 152 "/usr/include/google/protobuf/stubs/common.h" 3 4
typedef unsigned int uint;
# 165 "/usr/include/google/protobuf/stubs/common.h" 3 4
typedef int8_t int8;
typedef int16_t int16;
typedef int32_t int32;
typedef int64_t int64;

typedef uint8_t uint8;
typedef uint16_t uint16;
typedef uint32_t uint32;
typedef uint64_t uint64;
# 192 "/usr/include/google/protobuf/stubs/common.h" 3 4
static const int32 kint32max = 0x7FFFFFFF;
static const int32 kint32min = -kint32max - 1;
static const int64 kint64max = 0x7FFFFFFFFFFFFFFFLL;
static const int64 kint64min = -kint64max - 1;
static const uint32 kuint32max = 0xFFFFFFFFu;
static const uint64 kuint64max = 0xFFFFFFFFFFFFFFFFULL;
# 286 "/usr/include/google/protobuf/stubs/common.h" 3 4
namespace internal {
# 305 "/usr/include/google/protobuf/stubs/common.h" 3 4
template<typename To, typename From>
inline To implicit_cast(From const &f) {
  return f;
}
# 328 "/usr/include/google/protobuf/stubs/common.h" 3 4
template<typename To, typename From>
inline To down_cast(From* f) {




  if (false) {
    implicit_cast<From*, To>(0);
  }


  ((f == __null || dynamic_cast<To>(f) != __null) ? static_cast<void> (0) : __assert_fail ("f == __null || dynamic_cast<To>(f) != __null", "/usr/include/google/protobuf/stubs/common.h", 339, __PRETTY_FUNCTION__));

  return static_cast<To>(f);
}

}



using internal::implicit_cast;
using internal::down_cast;
# 366 "/usr/include/google/protobuf/stubs/common.h" 3 4
namespace internal {

template <bool>
struct CompileAssert {
};

}
# 424 "/usr/include/google/protobuf/stubs/common.h" 3 4
namespace internal {





template <class C> class scoped_ptr;
template <class C> class scoped_array;
# 440 "/usr/include/google/protobuf/stubs/common.h" 3 4
template <class C>
class scoped_ptr {
 public:


  typedef C element_type;




  explicit scoped_ptr(C* p = __null) : ptr_(p) { }



  ~scoped_ptr() {
    enum { type_must_be_complete = sizeof(C) };
    delete ptr_;
  }




  void reset(C* p = __null) {
    if (p != ptr_) {
      enum { type_must_be_complete = sizeof(C) };
      delete ptr_;
      ptr_ = p;
    }
  }



  C& operator*() const {
    ((ptr_ != __null) ? static_cast<void> (0) : __assert_fail ("ptr_ != __null", "/usr/include/google/protobuf/stubs/common.h", 473, __PRETTY_FUNCTION__));
    return *ptr_;
  }
  C* operator->() const {
    ((ptr_ != __null) ? static_cast<void> (0) : __assert_fail ("ptr_ != __null", "/usr/include/google/protobuf/stubs/common.h", 477, __PRETTY_FUNCTION__));
    return ptr_;
  }
  C* get() const { return ptr_; }




  bool operator==(C* p) const { return ptr_ == p; }
  bool operator!=(C* p) const { return ptr_ != p; }


  void swap(scoped_ptr& p2) {
    C* tmp = ptr_;
    ptr_ = p2.ptr_;
    p2.ptr_ = tmp;
  }






  C* release() {
    C* retVal = ptr_;
    ptr_ = __null;
    return retVal;
  }

 private:
  C* ptr_;




  template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
  template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;


  scoped_ptr(const scoped_ptr&);
  void operator=(const scoped_ptr&);
};
# 527 "/usr/include/google/protobuf/stubs/common.h" 3 4
template <class C>
class scoped_array {
 public:


  typedef C element_type;




  explicit scoped_array(C* p = __null) : array_(p) { }



  ~scoped_array() {
    enum { type_must_be_complete = sizeof(C) };
    delete[] array_;
  }




  void reset(C* p = __null) {
    if (p != array_) {
      enum { type_must_be_complete = sizeof(C) };
      delete[] array_;
      array_ = p;
    }
  }



  C& operator[](std::ptrdiff_t i) const {
    ((i >= 0) ? static_cast<void> (0) : __assert_fail ("i >= 0", "/usr/include/google/protobuf/stubs/common.h", 560, __PRETTY_FUNCTION__));
    ((array_ != __null) ? static_cast<void> (0) : __assert_fail ("array_ != __null", "/usr/include/google/protobuf/stubs/common.h", 561, __PRETTY_FUNCTION__));
    return array_[i];
  }



  C* get() const {
    return array_;
  }




  bool operator==(C* p) const { return array_ == p; }
  bool operator!=(C* p) const { return array_ != p; }


  void swap(scoped_array& p2) {
    C* tmp = array_;
    array_ = p2.array_;
    p2.array_ = tmp;
  }






  C* release() {
    C* retVal = array_;
    array_ = __null;
    return retVal;
  }

 private:
  C* array_;


  template <class C2> bool operator==(scoped_array<C2> const& p2) const;
  template <class C2> bool operator!=(scoped_array<C2> const& p2) const;


  scoped_array(const scoped_array&);
  void operator=(const scoped_array&);
};

}



using internal::scoped_ptr;
using internal::scoped_array;




enum LogLevel {
  LOGLEVEL_INFO,

  LOGLEVEL_WARNING,



  LOGLEVEL_ERROR,

  LOGLEVEL_FATAL,







  LOGLEVEL_DFATAL = LOGLEVEL_FATAL

};

namespace internal {

class LogFinisher;

class LogMessage {
 public:
  LogMessage(LogLevel level, const char* filename, int line);
  ~LogMessage();

  LogMessage& operator<<(const std::string& value);
  LogMessage& operator<<(const char* value);
  LogMessage& operator<<(char value);
  LogMessage& operator<<(int value);
  LogMessage& operator<<(uint value);
  LogMessage& operator<<(long value);
  LogMessage& operator<<(unsigned long value);
  LogMessage& operator<<(double value);

 private:
  friend class LogFinisher;
  void Finish();

  LogLevel level_;
  const char* filename_;
  int line_;
  std::string message_;
};



class LogFinisher {
 public:
  void operator=(LogMessage& other);
};

}
# 741 "/usr/include/google/protobuf/stubs/common.h" 3 4
typedef void LogHandler(LogLevel level, const char* filename, int line,
                        const std::string& message);
# 757 "/usr/include/google/protobuf/stubs/common.h" 3 4
 LogHandler* SetLogHandler(LogHandler* new_func);
# 766 "/usr/include/google/protobuf/stubs/common.h" 3 4
class LogSilencer {
 public:
  LogSilencer();
  ~LogSilencer();
};
# 832 "/usr/include/google/protobuf/stubs/common.h" 3 4
class Closure {
 public:
  Closure() {}
  virtual ~Closure();

  virtual void Run() = 0;

 private:
  Closure(const Closure&); void operator=(const Closure&);
};

namespace internal {

class FunctionClosure0 : public Closure {
 public:
  typedef void (*FunctionType)();

  FunctionClosure0(FunctionType function, bool self_deleting)
    : function_(function), self_deleting_(self_deleting) {}
  ~FunctionClosure0();

  void Run() {
    bool needs_delete = self_deleting_;
    function_();
    if (needs_delete) delete this;
  }

 private:
  FunctionType function_;
  bool self_deleting_;
};

template <typename Class>
class MethodClosure0 : public Closure {
 public:
  typedef void (Class::*MethodType)();

  MethodClosure0(Class* object, MethodType method, bool self_deleting)
    : object_(object), method_(method), self_deleting_(self_deleting) {}
  ~MethodClosure0() {}

  void Run() {
    bool needs_delete = self_deleting_;
    (object_->*method_)();
    if (needs_delete) delete this;
  }

 private:
  Class* object_;
  MethodType method_;
  bool self_deleting_;
};

template <typename Arg1>
class FunctionClosure1 : public Closure {
 public:
  typedef void (*FunctionType)(Arg1 arg1);

  FunctionClosure1(FunctionType function, bool self_deleting,
                   Arg1 arg1)
    : function_(function), self_deleting_(self_deleting),
      arg1_(arg1) {}
  ~FunctionClosure1() {}

  void Run() {
    bool needs_delete = self_deleting_;
    function_(arg1_);
    if (needs_delete) delete this;
  }

 private:
  FunctionType function_;
  bool self_deleting_;
  Arg1 arg1_;
};

template <typename Class, typename Arg1>
class MethodClosure1 : public Closure {
 public:
  typedef void (Class::*MethodType)(Arg1 arg1);

  MethodClosure1(Class* object, MethodType method, bool self_deleting,
                 Arg1 arg1)
    : object_(object), method_(method), self_deleting_(self_deleting),
      arg1_(arg1) {}
  ~MethodClosure1() {}

  void Run() {
    bool needs_delete = self_deleting_;
    (object_->*method_)(arg1_);
    if (needs_delete) delete this;
  }

 private:
  Class* object_;
  MethodType method_;
  bool self_deleting_;
  Arg1 arg1_;
};

template <typename Arg1, typename Arg2>
class FunctionClosure2 : public Closure {
 public:
  typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2);

  FunctionClosure2(FunctionType function, bool self_deleting,
                   Arg1 arg1, Arg2 arg2)
    : function_(function), self_deleting_(self_deleting),
      arg1_(arg1), arg2_(arg2) {}
  ~FunctionClosure2() {}

  void Run() {
    bool needs_delete = self_deleting_;
    function_(arg1_, arg2_);
    if (needs_delete) delete this;
  }

 private:
  FunctionType function_;
  bool self_deleting_;
  Arg1 arg1_;
  Arg2 arg2_;
};

template <typename Class, typename Arg1, typename Arg2>
class MethodClosure2 : public Closure {
 public:
  typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2);

  MethodClosure2(Class* object, MethodType method, bool self_deleting,
                 Arg1 arg1, Arg2 arg2)
    : object_(object), method_(method), self_deleting_(self_deleting),
      arg1_(arg1), arg2_(arg2) {}
  ~MethodClosure2() {}

  void Run() {
    bool needs_delete = self_deleting_;
    (object_->*method_)(arg1_, arg2_);
    if (needs_delete) delete this;
  }

 private:
  Class* object_;
  MethodType method_;
  bool self_deleting_;
  Arg1 arg1_;
  Arg2 arg2_;
};

}


inline Closure* NewCallback(void (*function)()) {
  return new internal::FunctionClosure0(function, true);
}


inline Closure* NewPermanentCallback(void (*function)()) {
  return new internal::FunctionClosure0(function, false);
}


template <typename Class>
inline Closure* NewCallback(Class* object, void (Class::*method)()) {
  return new internal::MethodClosure0<Class>(object, method, true);
}


template <typename Class>
inline Closure* NewPermanentCallback(Class* object, void (Class::*method)()) {
  return new internal::MethodClosure0<Class>(object, method, false);
}


template <typename Arg1>
inline Closure* NewCallback(void (*function)(Arg1),
                            Arg1 arg1) {
  return new internal::FunctionClosure1<Arg1>(function, true, arg1);
}


template <typename Arg1>
inline Closure* NewPermanentCallback(void (*function)(Arg1),
                                     Arg1 arg1) {
  return new internal::FunctionClosure1<Arg1>(function, false, arg1);
}


template <typename Class, typename Arg1>
inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1),
                            Arg1 arg1) {
  return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
}


template <typename Class, typename Arg1>
inline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1),
                                     Arg1 arg1) {
  return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
}


template <typename Arg1, typename Arg2>
inline Closure* NewCallback(void (*function)(Arg1, Arg2),
                            Arg1 arg1, Arg2 arg2) {
  return new internal::FunctionClosure2<Arg1, Arg2>(
    function, true, arg1, arg2);
}


template <typename Arg1, typename Arg2>
inline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2),
                                     Arg1 arg1, Arg2 arg2) {
  return new internal::FunctionClosure2<Arg1, Arg2>(
    function, false, arg1, arg2);
}


template <typename Class, typename Arg1, typename Arg2>
inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2),
                            Arg1 arg1, Arg2 arg2) {
  return new internal::MethodClosure2<Class, Arg1, Arg2>(
    object, method, true, arg1, arg2);
}


template <typename Class, typename Arg1, typename Arg2>
inline Closure* NewPermanentCallback(
    Class* object, void (Class::*method)(Arg1, Arg2),
    Arg1 arg1, Arg2 arg2) {
  return new internal::MethodClosure2<Class, Arg1, Arg2>(
    object, method, false, arg1, arg2);
}



void DoNothing();




namespace internal {




class Mutex {
 public:

  Mutex();


  ~Mutex();


  void Lock();


  void Unlock();



  void AssertHeld();

 private:
  struct Internal;
  Internal* mInternal;

  Mutex(const Mutex&); void operator=(const Mutex&);
};


class MutexLock {
 public:
  explicit MutexLock(Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
  ~MutexLock() { this->mu_->Unlock(); }
 private:
  Mutex *const mu_;
  MutexLock(const MutexLock&); void operator=(const MutexLock&);
};


typedef MutexLock ReaderMutexLock;
typedef MutexLock WriterMutexLock;


class MutexLockMaybe {
 public:
  explicit MutexLockMaybe(Mutex *mu) :
    mu_(mu) { if (this->mu_ != __null) { this->mu_->Lock(); } }
  ~MutexLockMaybe() { if (this->mu_ != __null) { this->mu_->Unlock(); } }
 private:
  Mutex *const mu_;
  MutexLockMaybe(const MutexLockMaybe&); void operator=(const MutexLockMaybe&);
};

}



using internal::Mutex;
using internal::MutexLock;
using internal::ReaderMutexLock;
using internal::WriterMutexLock;
using internal::MutexLockMaybe;




namespace internal {


template<typename T> struct remove_pointer { typedef T type; };
template<typename T> struct remove_pointer<T*> { typedef T type; };
template<typename T> struct remove_pointer<T* const> { typedef T type; };
template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
template<typename T> struct remove_pointer<T* const volatile> {
  typedef T type; };





 bool IsStructurallyValidUTF8(const char* buf, int len);

}
# 1175 "/usr/include/google/protobuf/stubs/common.h" 3 4
 void ShutdownProtobufLibrary();

namespace internal {


 void OnShutdown(void (*func)());

}


class FatalException : public std::exception {
 public:
  FatalException(const char* filename, int line, const std::string& message)
      : filename_(filename), line_(line), message_(message) {}
  virtual ~FatalException() throw();

  virtual const char* what() const throw();

  const char* filename() const { return filename_; }
  int line() const { return line_; }
  const std::string& message() const { return message_; }

 private:
  const char* filename_;
  const int line_;
  const std::string message_;
};




using namespace std;

}
}
# 10 "./drizzled/message/table.pb.h" 2
# 22 "./drizzled/message/table.pb.h"
# 1 "/usr/include/google/protobuf/generated_message_util.h" 1 3 4
# 46 "/usr/include/google/protobuf/generated_message_util.h" 3 4
namespace google {
namespace protobuf {
  namespace io {
    class CodedInputStream;
  }
}

namespace protobuf {
namespace internal {
# 71 "/usr/include/google/protobuf/generated_message_util.h" 3 4
double Infinity();
double NaN();


extern const ::std::string kEmptyString;


}
}

}
# 23 "./drizzled/message/table.pb.h" 2
# 1 "/usr/include/google/protobuf/repeated_field.h" 1 3 4
# 52 "/usr/include/google/protobuf/repeated_field.h" 3 4
# 1 "/usr/include/google/protobuf/message_lite.h" 1 3 4
# 43 "/usr/include/google/protobuf/message_lite.h" 3 4
# 1 "/usr/include/google/protobuf/io/coded_stream.h" 1 3 4
# 124 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
# 1 "/usr/include/i386-linux-gnu/sys/param.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/sys/param.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/sys/param.h" 2 3 4


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 27 "/usr/include/i386-linux-gnu/sys/param.h" 2 3 4

# 1 "/usr/include/signal.h" 1 3 4
# 30 "/usr/include/signal.h" 3 4
extern "C" {

# 1 "/usr/include/i386-linux-gnu/bits/sigset.h" 1 3 4
# 103 "/usr/include/i386-linux-gnu/bits/sigset.h" 3 4
extern int __sigismember (const __sigset_t *, int);
extern int __sigaddset (__sigset_t *, int);
extern int __sigdelset (__sigset_t *, int);
# 117 "/usr/include/i386-linux-gnu/bits/sigset.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int __sigismember (const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
extern __inline __attribute__ ((__gnu_inline__)) int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
extern __inline __attribute__ ((__gnu_inline__)) int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
# 33 "/usr/include/signal.h" 2 3 4







typedef __sig_atomic_t sig_atomic_t;

# 57 "/usr/include/signal.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/signum.h" 1 3 4
# 58 "/usr/include/signal.h" 2 3 4
# 80 "/usr/include/signal.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/siginfo.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/siginfo.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/bits/siginfo.h" 2 3 4







typedef union sigval
  {
    int sival_int;
    void *sival_ptr;
  } sigval_t;
# 58 "/usr/include/i386-linux-gnu/bits/siginfo.h" 3 4
typedef __clock_t __sigchld_clock_t;



typedef struct
  {
    int si_signo;
    int si_errno;

    int si_code;

    union
      {
 int _pad[((128 / sizeof (int)) - 3)];


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
   } _kill;


 struct
   {
     int si_tid;
     int si_overrun;
     sigval_t si_sigval;
   } _timer;


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
     sigval_t si_sigval;
   } _rt;


 struct
   {
     __pid_t si_pid;
     __uid_t si_uid;
     int si_status;
     __sigchld_clock_t si_utime;
     __sigchld_clock_t si_stime;
   } _sigchld;


 struct
   {
     void *si_addr;
   } _sigfault;


 struct
   {
     long int si_band;
     int si_fd;
   } _sigpoll;


 struct
   {
     void *_call_addr;
     int _syscall;
     unsigned int _arch;
   } _sigsys;
      } _sifields;
  } siginfo_t ;
# 151 "/usr/include/i386-linux-gnu/bits/siginfo.h" 3 4
enum
{
  SI_ASYNCNL = -60,

  SI_TKILL = -6,

  SI_SIGIO,

  SI_ASYNCIO,

  SI_MESGQ,

  SI_TIMER,

  SI_QUEUE,

  SI_USER,

  SI_KERNEL = 0x80

};



enum
{
  ILL_ILLOPC = 1,

  ILL_ILLOPN,

  ILL_ILLADR,

  ILL_ILLTRP,

  ILL_PRVOPC,

  ILL_PRVREG,

  ILL_COPROC,

  ILL_BADSTK

};


enum
{
  FPE_INTDIV = 1,

  FPE_INTOVF,

  FPE_FLTDIV,

  FPE_FLTOVF,

  FPE_FLTUND,

  FPE_FLTRES,

  FPE_FLTINV,

  FPE_FLTSUB

};


enum
{
  SEGV_MAPERR = 1,

  SEGV_ACCERR

};


enum
{
  BUS_ADRALN = 1,

  BUS_ADRERR,

  BUS_OBJERR

};


enum
{
  TRAP_BRKPT = 1,

  TRAP_TRACE

};


enum
{
  CLD_EXITED = 1,

  CLD_KILLED,

  CLD_DUMPED,

  CLD_TRAPPED,

  CLD_STOPPED,

  CLD_CONTINUED

};


enum
{
  POLL_IN = 1,

  POLL_OUT,

  POLL_MSG,

  POLL_ERR,

  POLL_PRI,

  POLL_HUP

};
# 301 "/usr/include/i386-linux-gnu/bits/siginfo.h" 3 4
typedef struct sigevent
  {
    sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
      {
 int _pad[((64 / sizeof (int)) - 3)];



 __pid_t _tid;

 struct
   {
     void (*_function) (sigval_t);
     pthread_attr_t *_attribute;
   } _sigev_thread;
      } _sigev_un;
  } sigevent_t;






enum
{
  SIGEV_SIGNAL = 0,

  SIGEV_NONE,

  SIGEV_THREAD,


  SIGEV_THREAD_ID = 4

};
# 81 "/usr/include/signal.h" 2 3 4




typedef void (*__sighandler_t) (int);




extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
     throw ();

extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
     throw ();







extern __sighandler_t signal (int __sig, __sighandler_t __handler)
     throw ();
# 114 "/usr/include/signal.h" 3 4





extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
     throw ();






extern int kill (__pid_t __pid, int __sig) throw ();






extern int killpg (__pid_t __pgrp, int __sig) throw ();




extern int raise (int __sig) throw ();




extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
     throw ();
extern int gsignal (int __sig) throw ();




extern void psignal (int __sig, const char *__s);




extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
# 169 "/usr/include/signal.h" 3 4
extern int __sigpause (int __sig_or_mask, int __is_sig);
# 178 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
# 197 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));


extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));


extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
# 212 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;




typedef __sighandler_t sig_t;





extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));


extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));


extern int sigismember (const sigset_t *__set, int __signo)
     throw () __attribute__ ((__nonnull__ (1)));



extern int sigisemptyset (const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));


extern int sigandset (sigset_t *__set, const sigset_t *__left,
        const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));


extern int sigorset (sigset_t *__set, const sigset_t *__left,
       const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));




# 1 "/usr/include/i386-linux-gnu/bits/sigaction.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/sigaction.h" 3 4
struct sigaction
  {


    union
      {

 __sighandler_t sa_handler;

 void (*sa_sigaction) (int, siginfo_t *, void *);
      }
    __sigaction_handler;







    __sigset_t sa_mask;


    int sa_flags;


    void (*sa_restorer) (void);
  };
# 254 "/usr/include/signal.h" 2 3 4


extern int sigprocmask (int __how, const sigset_t *__restrict __set,
   sigset_t *__restrict __oset) throw ();






extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));


extern int sigaction (int __sig, const struct sigaction *__restrict __act,
        struct sigaction *__restrict __oact) throw ();


extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));






extern int sigwait (const sigset_t *__restrict __set, int *__restrict __sig)
     __attribute__ ((__nonnull__ (1, 2)));






extern int sigwaitinfo (const sigset_t *__restrict __set,
   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));






extern int sigtimedwait (const sigset_t *__restrict __set,
    siginfo_t *__restrict __info,
    const struct timespec *__restrict __timeout)
     __attribute__ ((__nonnull__ (1)));



extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
     throw ();
# 311 "/usr/include/signal.h" 3 4
extern const char *const _sys_siglist[65];
extern const char *const sys_siglist[65];


struct sigvec
  {
    __sighandler_t sv_handler;
    int sv_mask;

    int sv_flags;

  };
# 335 "/usr/include/signal.h" 3 4
extern int sigvec (int __sig, const struct sigvec *__vec,
     struct sigvec *__ovec) throw ();



# 1 "/usr/include/i386-linux-gnu/bits/sigcontext.h" 1 3 4
# 29 "/usr/include/i386-linux-gnu/bits/sigcontext.h" 3 4
struct _fpx_sw_bytes
{
  __uint32_t magic1;
  __uint32_t extended_size;
  __uint64_t xstate_bv;
  __uint32_t xstate_size;
  __uint32_t padding[7];
};

struct _fpreg
{
  unsigned short significand[4];
  unsigned short exponent;
};

struct _fpxreg
{
  unsigned short significand[4];
  unsigned short exponent;
  unsigned short padding[3];
};

struct _xmmreg
{
  __uint32_t element[4];
};





struct _fpstate
{

  __uint32_t cw;
  __uint32_t sw;
  __uint32_t tag;
  __uint32_t ipoff;
  __uint32_t cssel;
  __uint32_t dataoff;
  __uint32_t datasel;
  struct _fpreg _st[8];
  unsigned short status;
  unsigned short magic;


  __uint32_t _fxsr_env[6];
  __uint32_t mxcsr;
  __uint32_t reserved;
  struct _fpxreg _fxsr_st[8];
  struct _xmmreg _xmm[8];
  __uint32_t padding[56];
};
# 93 "/usr/include/i386-linux-gnu/bits/sigcontext.h" 3 4
struct sigcontext
{
  unsigned short gs, __gsh;
  unsigned short fs, __fsh;
  unsigned short es, __esh;
  unsigned short ds, __dsh;
  unsigned long edi;
  unsigned long esi;
  unsigned long ebp;
  unsigned long esp;
  unsigned long ebx;
  unsigned long edx;
  unsigned long ecx;
  unsigned long eax;
  unsigned long trapno;
  unsigned long err;
  unsigned long eip;
  unsigned short cs, __csh;
  unsigned long eflags;
  unsigned long esp_at_signal;
  unsigned short ss, __ssh;
  struct _fpstate * fpstate;
  unsigned long oldmask;
  unsigned long cr2;
};
# 175 "/usr/include/i386-linux-gnu/bits/sigcontext.h" 3 4
struct _xsave_hdr
{
  __uint64_t xstate_bv;
  __uint64_t reserved1[2];
  __uint64_t reserved2[5];
};

struct _ymmh_state
{
  __uint32_t ymmh_space[64];
};

struct _xstate
{
  struct _fpstate fpstate;
  struct _xsave_hdr xstate_hdr;
  struct _ymmh_state ymmh;
};
# 341 "/usr/include/signal.h" 2 3 4


extern int sigreturn (struct sigcontext *__scp) throw ();






# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 351 "/usr/include/signal.h" 2 3 4




extern int siginterrupt (int __sig, int __interrupt) throw ();

# 1 "/usr/include/i386-linux-gnu/bits/sigstack.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/bits/sigstack.h" 3 4
struct sigstack
  {
    void *ss_sp;
    int ss_onstack;
  };



enum
{
  SS_ONSTACK = 1,

  SS_DISABLE

};
# 49 "/usr/include/i386-linux-gnu/bits/sigstack.h" 3 4
typedef struct sigaltstack
  {
    void *ss_sp;
    int ss_flags;
    size_t ss_size;
  } stack_t;
# 358 "/usr/include/signal.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/sys/ucontext.h" 1 3 4
# 22 "/usr/include/i386-linux-gnu/sys/ucontext.h" 3 4
# 1 "/usr/include/signal.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/sys/ucontext.h" 2 3 4
# 146 "/usr/include/i386-linux-gnu/sys/ucontext.h" 3 4
typedef int greg_t;





typedef greg_t gregset_t[19];



enum
{
  REG_GS = 0,

  REG_FS,

  REG_ES,

  REG_DS,

  REG_EDI,

  REG_ESI,

  REG_EBP,

  REG_ESP,

  REG_EBX,

  REG_EDX,

  REG_ECX,

  REG_EAX,

  REG_TRAPNO,

  REG_ERR,

  REG_EIP,

  REG_CS,

  REG_EFL,

  REG_UESP,

  REG_SS

};



struct _libc_fpreg
{
  unsigned short int significand[4];
  unsigned short int exponent;
};

struct _libc_fpstate
{
  unsigned long int cw;
  unsigned long int sw;
  unsigned long int tag;
  unsigned long int ipoff;
  unsigned long int cssel;
  unsigned long int dataoff;
  unsigned long int datasel;
  struct _libc_fpreg _st[8];
  unsigned long int status;
};


typedef struct _libc_fpstate *fpregset_t;


typedef struct
  {
    gregset_t gregs;


    fpregset_t fpregs;
    unsigned long int oldmask;
    unsigned long int cr2;
  } mcontext_t;


typedef struct ucontext
  {
    unsigned long int uc_flags;
    struct ucontext *uc_link;
    stack_t uc_stack;
    mcontext_t uc_mcontext;
    __sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
  } ucontext_t;
# 361 "/usr/include/signal.h" 2 3 4





extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
     throw () __attribute__ ((__deprecated__));



extern int sigaltstack (const struct sigaltstack *__restrict __ss,
   struct sigaltstack *__restrict __oss) throw ();







extern int sighold (int __sig) throw ();


extern int sigrelse (int __sig) throw ();


extern int sigignore (int __sig) throw ();


extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();






# 1 "/usr/include/i386-linux-gnu/bits/sigthread.h" 1 3 4
# 30 "/usr/include/i386-linux-gnu/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how,
       const __sigset_t *__restrict __newmask,
       __sigset_t *__restrict __oldmask)throw ();


extern int pthread_kill (pthread_t __threadid, int __signo) throw ();



extern int pthread_sigqueue (pthread_t __threadid, int __signo,
        const union sigval __value) throw ();
# 397 "/usr/include/signal.h" 2 3 4






extern int __libc_current_sigrtmin (void) throw ();

extern int __libc_current_sigrtmax (void) throw ();



}
# 29 "/usr/include/i386-linux-gnu/sys/param.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/param.h" 1 3 4
# 28 "/usr/include/i386-linux-gnu/bits/param.h" 3 4
# 1 "/usr/include/linux/param.h" 1 3 4



# 1 "/usr/include/i386-linux-gnu/asm/param.h" 1 3 4
# 1 "/usr/include/asm-generic/param.h" 1 3 4
# 1 "/usr/include/i386-linux-gnu/asm/param.h" 2 3 4
# 5 "/usr/include/linux/param.h" 2 3 4
# 29 "/usr/include/i386-linux-gnu/bits/param.h" 2 3 4
# 32 "/usr/include/i386-linux-gnu/sys/param.h" 2 3 4
# 125 "/usr/include/google/protobuf/io/coded_stream.h" 2 3 4
# 133 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
namespace google {
namespace protobuf {

class DescriptorPool;
class MessageFactory;

namespace io {


class CodedInputStream;
class CodedOutputStream;


class ZeroCopyInputStream;
class ZeroCopyOutputStream;
# 156 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
class CodedInputStream {
 public:

  explicit CodedInputStream(ZeroCopyInputStream* input);




  explicit CodedInputStream(const uint8* buffer, int size);






  ~CodedInputStream();




  bool Skip(int count);
# 185 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  bool GetDirectBufferPointer(const void** data, int* size);



  inline void GetDirectBufferPointerInline(const void** data,
                                           int* size) __attribute__ ((always_inline));


  bool ReadRaw(void* buffer, int size);
# 202 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  bool ReadString(string* buffer, int size);


  inline bool InternalReadStringInline(string* buffer,
                                       int size) __attribute__ ((always_inline));



  bool ReadLittleEndian32(uint32* value);

  bool ReadLittleEndian64(uint64* value);




  static const uint8* ReadLittleEndian32FromArray(const uint8* buffer,
                                                   uint32* value);

  static const uint8* ReadLittleEndian64FromArray(const uint8* buffer,
                                                   uint64* value);




  bool ReadVarint32(uint32* value);

  bool ReadVarint64(uint64* value);







  uint32 ReadTag() __attribute__ ((always_inline));
# 245 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  bool ExpectTag(uint32 expected) __attribute__ ((always_inline));
# 254 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  static const uint8* ExpectTagFromArray(
      const uint8* buffer,
      uint32 expected) __attribute__ ((always_inline));





  bool ExpectAtEnd();
# 273 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  bool LastTagWas(uint32 expected);







  bool ConsumedEntireMessage();
# 293 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  typedef int Limit;
# 306 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  Limit PushLimit(int byte_limit);



  void PopLimit(Limit limit);



  int BytesUntilLimit();
# 350 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  void SetTotalBytesLimit(int total_bytes_limit, int warning_threshold);
# 359 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  void SetRecursionLimit(int limit);



  bool IncrementRecursionDepth();


  void DecrementRecursionDepth();
# 436 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  void SetExtensionRegistry(DescriptorPool* pool, MessageFactory* factory);



  const DescriptorPool* GetExtensionPool();



  MessageFactory* GetExtensionFactory();

 private:
  CodedInputStream(const CodedInputStream&); void operator=(const CodedInputStream&);

  ZeroCopyInputStream* input_;
  const uint8* buffer_;
  const uint8* buffer_end_;
  int total_bytes_read_;




  int overflow_bytes_;


  uint32 last_tag_;




  bool legitimate_message_end_;


  bool aliasing_enabled_;


  Limit current_limit_;
# 480 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  int buffer_size_after_limit_;



  int total_bytes_limit_;
  int total_bytes_warning_threshold_;



  int recursion_depth_;

  int recursion_limit_;


  const DescriptorPool* extension_pool_;
  MessageFactory* extension_factory_;




  void Advance(int amount);


  void BackUpInputToCurrentPosition();



  void RecomputeBufferLimits();


  void PrintTotalBytesLimitError();



  bool Refresh();
# 523 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  bool ReadVarint32Fallback(uint32* value);
  bool ReadVarint64Fallback(uint64* value);
  bool ReadVarint32Slow(uint32* value);
  bool ReadVarint64Slow(uint64* value);
  bool ReadLittleEndian32Fallback(uint32* value);
  bool ReadLittleEndian64Fallback(uint64* value);



  uint32 ReadTagFallback();
  uint32 ReadTagSlow();
  bool ReadStringFallback(string* buffer, int size);


  int BufferSize() const;

  static const int kDefaultTotalBytesLimit = 64 << 20;

  static const int kDefaultTotalBytesWarningThreshold = 32 << 20;
  static const int kDefaultRecursionLimit = 64;
};
# 591 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
class CodedOutputStream {
 public:

  explicit CodedOutputStream(ZeroCopyOutputStream* output);



  ~CodedOutputStream();




  bool Skip(int count);
# 613 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  bool GetDirectBufferPointer(void** data, int* size);
# 622 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  inline uint8* GetDirectBufferForNBytesAndAdvance(int size);


  void WriteRaw(const void* buffer, int size);





  static uint8* WriteRawToArray(const void* buffer, int size, uint8* target);


  void WriteString(const string& str);

  static uint8* WriteStringToArray(const string& str, uint8* target);



  void WriteLittleEndian32(uint32 value);

  static uint8* WriteLittleEndian32ToArray(uint32 value, uint8* target);

  void WriteLittleEndian64(uint64 value);

  static uint8* WriteLittleEndian64ToArray(uint64 value, uint8* target);




  void WriteVarint32(uint32 value);

  static uint8* WriteVarint32ToArray(uint32 value, uint8* target);

  void WriteVarint64(uint64 value);

  static uint8* WriteVarint64ToArray(uint64 value, uint8* target);



  void WriteVarint32SignExtended(int32 value);

  static uint8* WriteVarint32SignExtendedToArray(int32 value, uint8* target);






  void WriteTag(uint32 value);

  static uint8* WriteTagToArray(
      uint32 value, uint8* target) __attribute__ ((always_inline));


  static int VarintSize32(uint32 value);

  static int VarintSize64(uint64 value);


  static int VarintSize32SignExtended(int32 value);


  inline int ByteCount() const;



  bool HadError() const { return had_error_; }

 private:
  CodedOutputStream(const CodedOutputStream&); void operator=(const CodedOutputStream&);

  ZeroCopyOutputStream* output_;
  uint8* buffer_;
  int buffer_size_;
  int total_bytes_;
  bool had_error_;


  void Advance(int amount);



  bool Refresh();

  static uint8* WriteVarint32FallbackToArray(uint32 value, uint8* target);
# 715 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  static uint8* WriteVarint32FallbackToArrayInline(
      uint32 value, uint8* target) __attribute__ ((always_inline));
  static uint8* WriteVarint64ToArrayInline(
      uint64 value, uint8* target) __attribute__ ((always_inline));

  static int VarintSize32Fallback(uint32 value);
};





inline bool CodedInputStream::ReadVarint32(uint32* value) {
  if ((__builtin_expect(!!(buffer_ < buffer_end_), 1)) && *buffer_ < 0x80) {
    *value = *buffer_;
    Advance(1);
    return true;
  } else {
    return ReadVarint32Fallback(value);
  }
}

inline bool CodedInputStream::ReadVarint64(uint64* value) {
  if ((__builtin_expect(!!(buffer_ < buffer_end_), 1)) && *buffer_ < 0x80) {
    *value = *buffer_;
    Advance(1);
    return true;
  } else {
    return ReadVarint64Fallback(value);
  }
}


inline const uint8* CodedInputStream::ReadLittleEndian32FromArray(
    const uint8* buffer,
    uint32* value) {

  memcpy(value, buffer, sizeof(*value));
  return buffer + sizeof(*value);







}

inline const uint8* CodedInputStream::ReadLittleEndian64FromArray(
    const uint8* buffer,
    uint64* value) {

  memcpy(value, buffer, sizeof(*value));
  return buffer + sizeof(*value);
# 782 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
}

inline bool CodedInputStream::ReadLittleEndian32(uint32* value) {

  if ((__builtin_expect(!!(BufferSize() >= static_cast<int>(sizeof(*value))), 1))) {
    memcpy(value, buffer_, sizeof(*value));
    Advance(sizeof(*value));
    return true;
  } else {
    return ReadLittleEndian32Fallback(value);
  }



}

inline bool CodedInputStream::ReadLittleEndian64(uint64* value) {

  if ((__builtin_expect(!!(BufferSize() >= static_cast<int>(sizeof(*value))), 1))) {
    memcpy(value, buffer_, sizeof(*value));
    Advance(sizeof(*value));
    return true;
  } else {
    return ReadLittleEndian64Fallback(value);
  }



}

inline uint32 CodedInputStream::ReadTag() {
  if ((__builtin_expect(!!(buffer_ < buffer_end_), 1)) && buffer_[0] < 0x80) {
    last_tag_ = buffer_[0];
    Advance(1);
    return last_tag_;
  } else {
    last_tag_ = ReadTagFallback();
    return last_tag_;
  }
}

inline bool CodedInputStream::LastTagWas(uint32 expected) {
  return last_tag_ == expected;
}

inline bool CodedInputStream::ConsumedEntireMessage() {
  return legitimate_message_end_;
}

inline bool CodedInputStream::ExpectTag(uint32 expected) {
  if (expected < (1 << 7)) {
    if ((__builtin_expect(!!(buffer_ < buffer_end_), 1)) && buffer_[0] == expected) {
      Advance(1);
      return true;
    } else {
      return false;
    }
  } else if (expected < (1 << 14)) {
    if ((__builtin_expect(!!(BufferSize() >= 2), 1)) &&
        buffer_[0] == static_cast<uint8>(expected | 0x80) &&
        buffer_[1] == static_cast<uint8>(expected >> 7)) {
      Advance(2);
      return true;
    } else {
      return false;
    }
  } else {

    return false;
  }
}

inline const uint8* CodedInputStream::ExpectTagFromArray(
    const uint8* buffer, uint32 expected) {
  if (expected < (1 << 7)) {
    if (buffer[0] == expected) {
      return buffer + 1;
    }
  } else if (expected < (1 << 14)) {
    if (buffer[0] == static_cast<uint8>(expected | 0x80) &&
        buffer[1] == static_cast<uint8>(expected >> 7)) {
      return buffer + 2;
    }
  }
  return __null;
}

inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
                                                           int* size) {
  *data = buffer_;
  *size = buffer_end_ - buffer_;
}

inline bool CodedInputStream::ExpectAtEnd() {



  if (buffer_ == buffer_end_ && buffer_size_after_limit_ != 0) {
    last_tag_ = 0;
    legitimate_message_end_ = true;
    return true;
  } else {
    return false;
  }
}

inline uint8* CodedOutputStream::GetDirectBufferForNBytesAndAdvance(int size) {
  if (buffer_size_ < size) {
    return __null;
  } else {
    uint8* result = buffer_;
    Advance(size);
    return result;
  }
}

inline uint8* CodedOutputStream::WriteVarint32ToArray(uint32 value,
                                                        uint8* target) {
  if (value < 0x80) {
    *target = value;
    return target + 1;
  } else {
    return WriteVarint32FallbackToArray(value, target);
  }
}

inline void CodedOutputStream::WriteVarint32SignExtended(int32 value) {
  if (value < 0) {
    WriteVarint64(static_cast<uint64>(value));
  } else {
    WriteVarint32(static_cast<uint32>(value));
  }
}

inline uint8* CodedOutputStream::WriteVarint32SignExtendedToArray(
    int32 value, uint8* target) {
  if (value < 0) {
    return WriteVarint64ToArray(static_cast<uint64>(value), target);
  } else {
    return WriteVarint32ToArray(static_cast<uint32>(value), target);
  }
}

inline uint8* CodedOutputStream::WriteLittleEndian32ToArray(uint32 value,
                                                            uint8* target) {

  memcpy(target, &value, sizeof(value));






  return target + sizeof(value);
}

inline uint8* CodedOutputStream::WriteLittleEndian64ToArray(uint64 value,
                                                            uint8* target) {

  memcpy(target, &value, sizeof(value));
# 955 "/usr/include/google/protobuf/io/coded_stream.h" 3 4
  return target + sizeof(value);
}

inline void CodedOutputStream::WriteTag(uint32 value) {
  WriteVarint32(value);
}

inline uint8* CodedOutputStream::WriteTagToArray(
    uint32 value, uint8* target) {
  if (value < (1 << 7)) {
    target[0] = value;
    return target + 1;
  } else if (value < (1 << 14)) {
    target[0] = static_cast<uint8>(value | 0x80);
    target[1] = static_cast<uint8>(value >> 7);
    return target + 2;
  } else {
    return WriteVarint32FallbackToArray(value, target);
  }
}

inline int CodedOutputStream::VarintSize32(uint32 value) {
  if (value < (1 << 7)) {
    return 1;
  } else {
    return VarintSize32Fallback(value);
  }
}

inline int CodedOutputStream::VarintSize32SignExtended(int32 value) {
  if (value < 0) {
    return 10;
  } else {
    return VarintSize32(static_cast<uint32>(value));
  }
}

inline void CodedOutputStream::WriteString(const string& str) {
  WriteRaw(str.data(), static_cast<int>(str.size()));
}

inline uint8* CodedOutputStream::WriteStringToArray(
    const string& str, uint8* target) {
  return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
}

inline int CodedOutputStream::ByteCount() const {
  return total_bytes_ - buffer_size_;
}

inline void CodedInputStream::Advance(int amount) {
  buffer_ += amount;
}

inline void CodedOutputStream::Advance(int amount) {
  buffer_ += amount;
  buffer_size_ -= amount;
}

inline void CodedInputStream::SetRecursionLimit(int limit) {
  recursion_limit_ = limit;
}

inline bool CodedInputStream::IncrementRecursionDepth() {
  ++recursion_depth_;
  return recursion_depth_ <= recursion_limit_;
}

inline void CodedInputStream::DecrementRecursionDepth() {
  if (recursion_depth_ > 0) --recursion_depth_;
}

inline void CodedInputStream::SetExtensionRegistry(DescriptorPool* pool,
                                                   MessageFactory* factory) {
  extension_pool_ = pool;
  extension_factory_ = factory;
}

inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
  return extension_pool_;
}

inline MessageFactory* CodedInputStream::GetExtensionFactory() {
  return extension_factory_;
}

inline int CodedInputStream::BufferSize() const {
  return buffer_end_ - buffer_;
}

inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
  : input_(input),
    buffer_(__null),
    buffer_end_(__null),
    total_bytes_read_(0),
    overflow_bytes_(0),
    last_tag_(0),
    legitimate_message_end_(false),
    aliasing_enabled_(false),
    current_limit_(kint32max),
    buffer_size_after_limit_(0),
    total_bytes_limit_(kDefaultTotalBytesLimit),
    total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
    recursion_depth_(0),
    recursion_limit_(kDefaultRecursionLimit),
    extension_pool_(__null),
    extension_factory_(__null) {

  Refresh();
}

inline CodedInputStream::CodedInputStream(const uint8* buffer, int size)
  : input_(__null),
    buffer_(buffer),
    buffer_end_(buffer + size),
    total_bytes_read_(size),
    overflow_bytes_(0),
    last_tag_(0),
    legitimate_message_end_(false),
    aliasing_enabled_(false),
    current_limit_(size),
    buffer_size_after_limit_(0),
    total_bytes_limit_(kDefaultTotalBytesLimit),
    total_bytes_warning_threshold_(kDefaultTotalBytesWarningThreshold),
    recursion_depth_(0),
    recursion_limit_(kDefaultRecursionLimit),
    extension_pool_(__null),
    extension_factory_(__null) {


}

inline CodedInputStream::~CodedInputStream() {
  if (input_ != __null) {
    BackUpInputToCurrentPosition();
  }
}

}
}






}
# 44 "/usr/include/google/protobuf/message_lite.h" 2 3 4

namespace google {
namespace protobuf {
# 71 "/usr/include/google/protobuf/message_lite.h" 3 4
class MessageLite {
 public:
  inline MessageLite() {}
  virtual ~MessageLite();




  virtual string GetTypeName() const = 0;



  virtual MessageLite* New() const = 0;






  virtual void Clear() = 0;


  virtual bool IsInitialized() const = 0;




  virtual string InitializationErrorString() const;



  virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
# 111 "/usr/include/google/protobuf/message_lite.h" 3 4
  bool ParseFromCodedStream(io::CodedInputStream* input);


  bool ParsePartialFromCodedStream(io::CodedInputStream* input);


  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);


  bool ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream* input);



  bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);


  bool ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
                                             int size);

  bool ParseFromString(const string& data);


  bool ParsePartialFromString(const string& data);

  bool ParseFromArray(const void* data, int size);


  bool ParsePartialFromArray(const void* data, int size);
# 152 "/usr/include/google/protobuf/message_lite.h" 3 4
  bool MergeFromCodedStream(io::CodedInputStream* input);






  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0;
# 168 "/usr/include/google/protobuf/message_lite.h" 3 4
  bool SerializeToCodedStream(io::CodedOutputStream* output) const;

  bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;


  bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;

  bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;


  bool SerializeToString(string* output) const;

  bool SerializePartialToString(string* output) const;


  bool SerializeToArray(void* data, int size) const;

  bool SerializePartialToArray(void* data, int size) const;







  string SerializeAsString() const;

  string SerializePartialAsString() const;



  bool AppendToString(string* output) const;

  bool AppendPartialToString(string* output) const;




  virtual int ByteSize() const = 0;




  virtual void SerializeWithCachedSizes(
      io::CodedOutputStream* output) const = 0;




  virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const;
# 230 "/usr/include/google/protobuf/message_lite.h" 3 4
  virtual int GetCachedSize() const = 0;

 private:
  MessageLite(const MessageLite&); void operator=(const MessageLite&);
};

}

}
# 53 "/usr/include/google/protobuf/repeated_field.h" 2 3 4

namespace google {

namespace protobuf {

class Message;

namespace internal {


 int StringSpaceUsedExcludingSelf(const string& str);

}





template <typename Element>
class RepeatedField {
 public:
  RepeatedField();
  RepeatedField(const RepeatedField& other);
  ~RepeatedField();

  RepeatedField& operator=(const RepeatedField& other);

  int size() const;

  const Element& Get(int index) const;
  Element* Mutable(int index);
  void Set(int index, const Element& value);
  void Add(const Element& value);
  Element* Add();






  void RemoveLast();
  void Clear();
  void MergeFrom(const RepeatedField& other);
  void CopyFrom(const RepeatedField& other);



  void Reserve(int new_size);


  void Truncate(int new_size);

  void AddAlreadyReserved(const Element& value);
  Element* AddAlreadyReserved();
  int Capacity() const;



  Element* mutable_data();
  const Element* data() const;


  void Swap(RepeatedField* other);


  void SwapElements(int index1, int index2);


  typedef Element* iterator;
  typedef const Element* const_iterator;
  typedef Element value_type;

  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;



  int SpaceUsedExcludingSelf() const;

 private:
  static const int kInitialSize = 4;

  Element* elements_;
  int current_size_;
  int total_size_;

  Element initial_space_[kInitialSize];




  void MoveArray(Element to[], Element from[], int size);


  void CopyArray(Element to[], const Element from[], int size);
};

namespace internal {
template <typename It> class RepeatedPtrIterator;
template <typename It> class RepeatedPtrOverPtrsIterator;
}

namespace internal {
# 175 "/usr/include/google/protobuf/repeated_field.h" 3 4
class RepeatedPtrFieldBase {
 protected:



  friend class GeneratedMessageReflection;






  friend class ExtensionSet;

  RepeatedPtrFieldBase();


  template <typename TypeHandler>
  void Destroy();

  int size() const;

  template <typename TypeHandler>
  const typename TypeHandler::Type& Get(int index) const;
  template <typename TypeHandler>
  typename TypeHandler::Type* Mutable(int index);
  template <typename TypeHandler>
  typename TypeHandler::Type* Add();
  template <typename TypeHandler>
  void RemoveLast();
  template <typename TypeHandler>
  void Clear();
  template <typename TypeHandler>
  void MergeFrom(const RepeatedPtrFieldBase& other);
  template <typename TypeHandler>
  void CopyFrom(const RepeatedPtrFieldBase& other);

  void Reserve(int new_size);

  int Capacity() const;


  void* const* raw_data() const;
  void** raw_mutable_data() const;

  template <typename TypeHandler>
  typename TypeHandler::Type** mutable_data();
  template <typename TypeHandler>
  const typename TypeHandler::Type* const* data() const;

  void Swap(RepeatedPtrFieldBase* other);

  void SwapElements(int index1, int index2);

  template <typename TypeHandler>
  int SpaceUsedExcludingSelf() const;





  template <typename TypeHandler>
  typename TypeHandler::Type* AddFromCleared();

  template <typename TypeHandler>
  void AddAllocated(typename TypeHandler::Type* value);
  template <typename TypeHandler>
  typename TypeHandler::Type* ReleaseLast();

  int ClearedCount() const;
  template <typename TypeHandler>
  void AddCleared(typename TypeHandler::Type* value);
  template <typename TypeHandler>
  typename TypeHandler::Type* ReleaseCleared();

 private:
  RepeatedPtrFieldBase(const RepeatedPtrFieldBase&); void operator=(const RepeatedPtrFieldBase&);

  static const int kInitialSize = 4;

  void** elements_;
  int current_size_;
  int allocated_size_;
  int total_size_;

  void* initial_space_[kInitialSize];

  template <typename TypeHandler>
  static inline typename TypeHandler::Type* cast(void* element) {
    return reinterpret_cast<typename TypeHandler::Type*>(element);
  }
  template <typename TypeHandler>
  static inline const typename TypeHandler::Type* cast(const void* element) {
    return reinterpret_cast<const typename TypeHandler::Type*>(element);
  }
};

template <typename GenericType>
class GenericTypeHandler {
 public:
  typedef GenericType Type;
  static GenericType* New() { return new GenericType; }
  static void Delete(GenericType* value) { delete value; }
  static void Clear(GenericType* value) { value->Clear(); }
  static void Merge(const GenericType& from, GenericType* to) {
    to->MergeFrom(from);
  }
  static int SpaceUsed(const GenericType& value) { return value.SpaceUsed(); }
};

template <>
inline void GenericTypeHandler<MessageLite>::Merge(
    const MessageLite& from, MessageLite* to) {
  to->CheckTypeAndMergeFrom(from);
}
# 299 "/usr/include/google/protobuf/repeated_field.h" 3 4
class StringTypeHandlerBase {
 public:
  typedef string Type;
  static string* New();
  static void Delete(string* value);
  static void Clear(string* value) { value->clear(); }
  static void Merge(const string& from, string* to) { *to = from; }
};

class StringTypeHandler : public StringTypeHandlerBase {
 public:
  static int SpaceUsed(const string& value) {
    return sizeof(value) + StringSpaceUsedExcludingSelf(value);
  }
};


}



template <typename Element>
class RepeatedPtrField : public internal::RepeatedPtrFieldBase {
 public:
  RepeatedPtrField();
  RepeatedPtrField(const RepeatedPtrField& other);
  ~RepeatedPtrField();

  RepeatedPtrField& operator=(const RepeatedPtrField& other);

  int size() const;

  const Element& Get(int index) const;
  Element* Mutable(int index);
  Element* Add();
  void RemoveLast();
  void Clear();
  void MergeFrom(const RepeatedPtrField& other);
  void CopyFrom(const RepeatedPtrField& other);




  void Reserve(int new_size);

  int Capacity() const;



  Element** mutable_data();
  const Element* const* data() const;


  void Swap(RepeatedPtrField* other);


  void SwapElements(int index1, int index2);


  typedef internal::RepeatedPtrIterator<Element> iterator;
  typedef internal::RepeatedPtrIterator<const Element> const_iterator;
  typedef Element value_type;

  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;



  typedef internal::RepeatedPtrOverPtrsIterator<Element> pointer_iterator;
  pointer_iterator pointer_begin();
  pointer_iterator pointer_end();



  int SpaceUsedExcludingSelf() const;







  void AddAllocated(Element* value);



  Element* ReleaseLast();
# 400 "/usr/include/google/protobuf/repeated_field.h" 3 4
  int ClearedCount() const;



  void AddCleared(Element* value);



  Element* ReleaseCleared();

 protected:




  class TypeHandler;

};



template <typename Element>
inline RepeatedField<Element>::RepeatedField()
  : elements_(initial_space_),
    current_size_(0),
    total_size_(kInitialSize) {
}

template <typename Element>
inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
  : elements_(initial_space_),
    current_size_(0),
    total_size_(kInitialSize) {
  CopyFrom(other);
}

template <typename Element>
RepeatedField<Element>::~RepeatedField() {
  if (elements_ != initial_space_) {
    delete [] elements_;
  }
}

template <typename Element>
inline RepeatedField<Element>&
RepeatedField<Element>::operator=(const RepeatedField& other) {
  CopyFrom(other);
  return *this;
}

template <typename Element>
inline int RepeatedField<Element>::size() const {
  return current_size_;
}

template <typename Element>
inline int RepeatedField<Element>::Capacity() const {
  return total_size_;
}

template<typename Element>
inline void RepeatedField<Element>::AddAlreadyReserved(const Element& value) {
  !(!((size()) < (Capacity()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 462) << "CHECK failed: " "(size()) < (Capacity())" ": ";
  elements_[current_size_++] = value;
}

template<typename Element>
inline Element* RepeatedField<Element>::AddAlreadyReserved() {
  !(!((size()) < (Capacity()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 468) << "CHECK failed: " "(size()) < (Capacity())" ": ";
  return &elements_[current_size_++];
}

template <typename Element>
inline const Element& RepeatedField<Element>::Get(int index) const {
  !(!((index) < (size()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 474) << "CHECK failed: " "(index) < (size())" ": ";
  return elements_[index];
}

template <typename Element>
inline Element* RepeatedField<Element>::Mutable(int index) {
  !(!((index) < (size()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 480) << "CHECK failed: " "(index) < (size())" ": ";
  return elements_ + index;
}

template <typename Element>
inline void RepeatedField<Element>::Set(int index, const Element& value) {
  !(!((index) < (size()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 486) << "CHECK failed: " "(index) < (size())" ": ";
  elements_[index] = value;
}

template <typename Element>
inline void RepeatedField<Element>::Add(const Element& value) {
  if (current_size_ == total_size_) Reserve(total_size_ + 1);
  elements_[current_size_++] = value;
}

template <typename Element>
inline Element* RepeatedField<Element>::Add() {
  if (current_size_ == total_size_) Reserve(total_size_ + 1);
  return &elements_[current_size_++];
}

template <typename Element>
inline void RepeatedField<Element>::RemoveLast() {
  !(!((current_size_) > (0))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 504) << "CHECK failed: " "(current_size_) > (0)" ": ";
  --current_size_;
}

template <typename Element>
inline void RepeatedField<Element>::Clear() {
  current_size_ = 0;
}

template <typename Element>
inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other) {
  Reserve(current_size_ + other.current_size_);
  CopyArray(elements_ + current_size_, other.elements_, other.current_size_);
  current_size_ += other.current_size_;
}

template <typename Element>
inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
  Clear();
  MergeFrom(other);
}

template <typename Element>
inline Element* RepeatedField<Element>::mutable_data() {
  return elements_;
}

template <typename Element>
inline const Element* RepeatedField<Element>::data() const {
  return elements_;
}


template <typename Element>
void RepeatedField<Element>::Swap(RepeatedField* other) {
  Element* swap_elements = elements_;
  int swap_current_size = current_size_;
  int swap_total_size = total_size_;


  Element swap_initial_space[kInitialSize];
  MoveArray(swap_initial_space, initial_space_, kInitialSize);

  elements_ = other->elements_;
  current_size_ = other->current_size_;
  total_size_ = other->total_size_;
  MoveArray(initial_space_, other->initial_space_, kInitialSize);

  other->elements_ = swap_elements;
  other->current_size_ = swap_current_size;
  other->total_size_ = swap_total_size;
  MoveArray(other->initial_space_, swap_initial_space, kInitialSize);

  if (elements_ == other->initial_space_) {
    elements_ = initial_space_;
  }
  if (other->elements_ == initial_space_) {
    other->elements_ = other->initial_space_;
  }
}

template <typename Element>
void RepeatedField<Element>::SwapElements(int index1, int index2) {
  std::swap(elements_[index1], elements_[index2]);
}

template <typename Element>
inline typename RepeatedField<Element>::iterator
RepeatedField<Element>::begin() {
  return elements_;
}
template <typename Element>
inline typename RepeatedField<Element>::const_iterator
RepeatedField<Element>::begin() const {
  return elements_;
}
template <typename Element>
inline typename RepeatedField<Element>::iterator
RepeatedField<Element>::end() {
  return elements_ + current_size_;
}
template <typename Element>
inline typename RepeatedField<Element>::const_iterator
RepeatedField<Element>::end() const {
  return elements_ + current_size_;
}

template <typename Element>
inline int RepeatedField<Element>::SpaceUsedExcludingSelf() const {
  return (elements_ != initial_space_) ? total_size_ * sizeof(elements_[0]) : 0;
}



template <typename Element>
void RepeatedField<Element>::Reserve(int new_size) {
  if (total_size_ >= new_size) return;

  Element* old_elements = elements_;
  total_size_ = max(total_size_ * 2, new_size);
  elements_ = new Element[total_size_];
  MoveArray(elements_, old_elements, current_size_);
  if (old_elements != initial_space_) {
    delete [] old_elements;
  }
}

template <typename Element>
inline void RepeatedField<Element>::Truncate(int new_size) {
  !(!((new_size) <= (current_size_))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 613) << "CHECK failed: " "(new_size) <= (current_size_)" ": ";
  current_size_ = new_size;
}

template <typename Element>
inline void RepeatedField<Element>::MoveArray(
    Element to[], Element from[], int array_size) {
  memcpy(to, from, array_size * sizeof(Element));
}

template <typename Element>
inline void RepeatedField<Element>::CopyArray(
    Element to[], const Element from[], int array_size) {
  memcpy(to, from, array_size * sizeof(Element));
}




namespace internal {

inline RepeatedPtrFieldBase::RepeatedPtrFieldBase()
  : elements_(initial_space_),
    current_size_(0),
    allocated_size_(0),
    total_size_(kInitialSize) {
}

template <typename TypeHandler>
void RepeatedPtrFieldBase::Destroy() {
  for (int i = 0; i < allocated_size_; i++) {
    TypeHandler::Delete(cast<TypeHandler>(elements_[i]));
  }
  if (elements_ != initial_space_) {
    delete [] elements_;
  }
}

inline int RepeatedPtrFieldBase::size() const {
  return current_size_;
}


template <typename TypeHandler>
inline const typename TypeHandler::Type&
RepeatedPtrFieldBase::Get(int index) const {
  !(!((index) < (size()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 659) << "CHECK failed: " "(index) < (size())" ": ";
  return *cast<TypeHandler>(elements_[index]);
}

template <typename TypeHandler>
inline typename TypeHandler::Type*
RepeatedPtrFieldBase::Mutable(int index) {
  !(!((index) < (size()))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 666) << "CHECK failed: " "(index) < (size())" ": ";
  return cast<TypeHandler>(elements_[index]);
}

template <typename TypeHandler>
inline typename TypeHandler::Type* RepeatedPtrFieldBase::Add() {
  if (current_size_ < allocated_size_) {
    return cast<TypeHandler>(elements_[current_size_++]);
  }
  if (allocated_size_ == total_size_) Reserve(total_size_ + 1);
  ++allocated_size_;
  typename TypeHandler::Type* result = TypeHandler::New();
  elements_[current_size_++] = result;
  return result;
}

template <typename TypeHandler>
inline void RepeatedPtrFieldBase::RemoveLast() {
  !(!((current_size_) > (0))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 684) << "CHECK failed: " "(current_size_) > (0)" ": ";
  TypeHandler::Clear(cast<TypeHandler>(elements_[--current_size_]));
}

template <typename TypeHandler>
void RepeatedPtrFieldBase::Clear() {
  for (int i = 0; i < current_size_; i++) {
    TypeHandler::Clear(cast<TypeHandler>(elements_[i]));
  }
  current_size_ = 0;
}

template <typename TypeHandler>
inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
  Reserve(current_size_ + other.current_size_);
  for (int i = 0; i < other.current_size_; i++) {
    TypeHandler::Merge(other.template Get<TypeHandler>(i), Add<TypeHandler>());
  }
}

template <typename TypeHandler>
inline void RepeatedPtrFieldBase::CopyFrom(const RepeatedPtrFieldBase& other) {
  RepeatedPtrFieldBase::Clear<TypeHandler>();
  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
}

inline int RepeatedPtrFieldBase::Capacity() const {
  return total_size_;
}

inline void* const* RepeatedPtrFieldBase::raw_data() const {
  return elements_;
}

inline void** RepeatedPtrFieldBase::raw_mutable_data() const {
  return elements_;
}

template <typename TypeHandler>
inline typename TypeHandler::Type** RepeatedPtrFieldBase::mutable_data() {


  return reinterpret_cast<typename TypeHandler::Type**>(elements_);
}

template <typename TypeHandler>
inline const typename TypeHandler::Type* const*
RepeatedPtrFieldBase::data() const {


  return reinterpret_cast<const typename TypeHandler::Type* const*>(elements_);
}

inline void RepeatedPtrFieldBase::SwapElements(int index1, int index2) {
  std::swap(elements_[index1], elements_[index2]);
}

template <typename TypeHandler>
inline int RepeatedPtrFieldBase::SpaceUsedExcludingSelf() const {
  int allocated_bytes =
      (elements_ != initial_space_) ? total_size_ * sizeof(elements_[0]) : 0;
  for (int i = 0; i < allocated_size_; ++i) {
    allocated_bytes += TypeHandler::SpaceUsed(*cast<TypeHandler>(elements_[i]));
  }
  return allocated_bytes;
}

template <typename TypeHandler>
inline typename TypeHandler::Type* RepeatedPtrFieldBase::AddFromCleared() {
  if (current_size_ < allocated_size_) {
    return cast<TypeHandler>(elements_[current_size_++]);
  } else {
    return __null;
  }
}

template <typename TypeHandler>
void RepeatedPtrFieldBase::AddAllocated(
    typename TypeHandler::Type* value) {

  if (current_size_ == total_size_) {

    Reserve(total_size_ + 1);
    ++allocated_size_;
  } else if (allocated_size_ == total_size_) {




    TypeHandler::Delete(cast<TypeHandler>(elements_[current_size_]));
  } else if (current_size_ < allocated_size_) {


    elements_[allocated_size_] = elements_[current_size_];
    ++allocated_size_;
  } else {

    ++allocated_size_;
  }

  elements_[current_size_++] = value;
}

template <typename TypeHandler>
inline typename TypeHandler::Type* RepeatedPtrFieldBase::ReleaseLast() {
  !(!((current_size_) > (0))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 789) << "CHECK failed: " "(current_size_) > (0)" ": ";
  typename TypeHandler::Type* result =
      cast<TypeHandler>(elements_[--current_size_]);
  --allocated_size_;
  if (current_size_ < allocated_size_) {


    elements_[current_size_] = elements_[allocated_size_];
  }
  return result;
}


inline int RepeatedPtrFieldBase::ClearedCount() const {
  return allocated_size_ - current_size_;
}

template <typename TypeHandler>
inline void RepeatedPtrFieldBase::AddCleared(
    typename TypeHandler::Type* value) {
  if (allocated_size_ == total_size_) Reserve(total_size_ + 1);
  elements_[allocated_size_++] = value;
}

template <typename TypeHandler>
inline typename TypeHandler::Type* RepeatedPtrFieldBase::ReleaseCleared() {
  !(!((allocated_size_) > (current_size_))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/repeated_field.h", 815) << "CHECK failed: " "(allocated_size_) > (current_size_)" ": ";
  return cast<TypeHandler>(elements_[--allocated_size_]);
}

}



template <typename Element>
class RepeatedPtrField<Element>::TypeHandler
    : public internal::GenericTypeHandler<Element> {};

template <>
class RepeatedPtrField<string>::TypeHandler
    : public internal::StringTypeHandler {};


template <typename Element>
inline RepeatedPtrField<Element>::RepeatedPtrField() {}

template <typename Element>
inline RepeatedPtrField<Element>::RepeatedPtrField(
    const RepeatedPtrField& other) {
  CopyFrom(other);
}

template <typename Element>
RepeatedPtrField<Element>::~RepeatedPtrField() {
  Destroy<TypeHandler>();
}

template <typename Element>
inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
    const RepeatedPtrField& other) {
  CopyFrom(other);
  return *this;
}

template <typename Element>
inline int RepeatedPtrField<Element>::size() const {
  return RepeatedPtrFieldBase::size();
}

template <typename Element>
inline const Element& RepeatedPtrField<Element>::Get(int index) const {
  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
}

template <typename Element>
inline Element* RepeatedPtrField<Element>::Mutable(int index) {
  return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
}

template <typename Element>
inline Element* RepeatedPtrField<Element>::Add() {
  return RepeatedPtrFieldBase::Add<TypeHandler>();
}

template <typename Element>
inline void RepeatedPtrField<Element>::RemoveLast() {
  RepeatedPtrFieldBase::RemoveLast<TypeHandler>();
}

template <typename Element>
inline void RepeatedPtrField<Element>::Clear() {
  RepeatedPtrFieldBase::Clear<TypeHandler>();
}

template <typename Element>
inline void RepeatedPtrField<Element>::MergeFrom(
    const RepeatedPtrField& other) {
  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
}

template <typename Element>
inline void RepeatedPtrField<Element>::CopyFrom(
    const RepeatedPtrField& other) {
  RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
}

template <typename Element>
inline Element** RepeatedPtrField<Element>::mutable_data() {
  return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
}

template <typename Element>
inline const Element* const* RepeatedPtrField<Element>::data() const {
  return RepeatedPtrFieldBase::data<TypeHandler>();
}

template <typename Element>
void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other) {
  RepeatedPtrFieldBase::Swap(other);
}

template <typename Element>
void RepeatedPtrField<Element>::SwapElements(int index1, int index2) {
  RepeatedPtrFieldBase::SwapElements(index1, index2);
}

template <typename Element>
inline int RepeatedPtrField<Element>::SpaceUsedExcludingSelf() const {
  return RepeatedPtrFieldBase::SpaceUsedExcludingSelf<TypeHandler>();
}

template <typename Element>
inline void RepeatedPtrField<Element>::AddAllocated(Element* value) {
  RepeatedPtrFieldBase::AddAllocated<TypeHandler>(value);
}

template <typename Element>
inline Element* RepeatedPtrField<Element>::ReleaseLast() {
  return RepeatedPtrFieldBase::ReleaseLast<TypeHandler>();
}


template <typename Element>
inline int RepeatedPtrField<Element>::ClearedCount() const {
  return RepeatedPtrFieldBase::ClearedCount();
}

template <typename Element>
inline void RepeatedPtrField<Element>::AddCleared(Element* value) {
  return RepeatedPtrFieldBase::AddCleared<TypeHandler>(value);
}

template <typename Element>
inline Element* RepeatedPtrField<Element>::ReleaseCleared() {
  return RepeatedPtrFieldBase::ReleaseCleared<TypeHandler>();
}

template <typename Element>
inline void RepeatedPtrField<Element>::Reserve(int new_size) {
  return RepeatedPtrFieldBase::Reserve(new_size);
}

template <typename Element>
inline int RepeatedPtrField<Element>::Capacity() const {
  return RepeatedPtrFieldBase::Capacity();
}



namespace internal {
# 971 "/usr/include/google/protobuf/repeated_field.h" 3 4
template<typename Element>
class RepeatedPtrIterator
    : public std::iterator<
          std::random_access_iterator_tag, Element> {
 public:
  typedef RepeatedPtrIterator<Element> iterator;
  typedef std::iterator<
          std::random_access_iterator_tag, Element> superclass;



  typedef typename superclass::reference reference;
  typedef typename superclass::pointer pointer;
  typedef typename superclass::difference_type difference_type;

  RepeatedPtrIterator() : it_(__null) {}
  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}



  template<typename OtherElement>
  RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other)
      : it_(other.it_) {

    if (false) {
      implicit_cast<Element*, OtherElement*>(0);
    }
  }


  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
  pointer operator->() const { return &(operator*()); }


  iterator& operator++() { ++it_; return *this; }
  iterator operator++(int) { return iterator(it_++); }
  iterator& operator--() { --it_; return *this; }
  iterator operator--(int) { return iterator(it_--); }


  bool operator==(const iterator& x) const { return it_ == x.it_; }
  bool operator!=(const iterator& x) const { return it_ != x.it_; }


  bool operator<(const iterator& x) const { return it_ < x.it_; }
  bool operator<=(const iterator& x) const { return it_ <= x.it_; }
  bool operator>(const iterator& x) const { return it_ > x.it_; }
  bool operator>=(const iterator& x) const { return it_ >= x.it_; }


  iterator& operator+=(difference_type d) {
    it_ += d;
    return *this;
  }
  friend iterator operator+(iterator it, difference_type d) {
    it += d;
    return it;
  }
  friend iterator operator+(difference_type d, iterator it) {
    it += d;
    return it;
  }
  iterator& operator-=(difference_type d) {
    it_ -= d;
    return *this;
  }
  friend iterator operator-(iterator it, difference_type d) {
    it -= d;
    return it;
  }


  reference operator[](difference_type d) const { return *(*this + d); }


  difference_type operator-(const iterator& x) const { return it_ - x.it_; }

 private:
  template<typename OtherElement>
  friend class RepeatedPtrIterator;


  void* const* it_;
};





template<typename Element>
class RepeatedPtrOverPtrsIterator
    : public std::iterator<std::random_access_iterator_tag, Element*> {
 public:
  typedef RepeatedPtrOverPtrsIterator<Element> iterator;
  typedef std::iterator<
          std::random_access_iterator_tag, Element*> superclass;



  typedef typename superclass::reference reference;
  typedef typename superclass::pointer pointer;
  typedef typename superclass::difference_type difference_type;

  RepeatedPtrOverPtrsIterator() : it_(__null) {}
  explicit RepeatedPtrOverPtrsIterator(void** it) : it_(it) {}


  reference operator*() const { return *reinterpret_cast<Element**>(it_); }
  pointer operator->() const { return &(operator*()); }


  iterator& operator++() { ++it_; return *this; }
  iterator operator++(int) { return iterator(it_++); }
  iterator& operator--() { --it_; return *this; }
  iterator operator--(int) { return iterator(it_--); }


  bool operator==(const iterator& x) const { return it_ == x.it_; }
  bool operator!=(const iterator& x) const { return it_ != x.it_; }


  bool operator<(const iterator& x) const { return it_ < x.it_; }
  bool operator<=(const iterator& x) const { return it_ <= x.it_; }
  bool operator>(const iterator& x) const { return it_ > x.it_; }
  bool operator>=(const iterator& x) const { return it_ >= x.it_; }


  iterator& operator+=(difference_type d) {
    it_ += d;
    return *this;
  }
  friend iterator operator+(iterator it, difference_type d) {
    it += d;
    return it;
  }
  friend iterator operator+(difference_type d, iterator it) {
    it += d;
    return it;
  }
  iterator& operator-=(difference_type d) {
    it_ -= d;
    return *this;
  }
  friend iterator operator-(iterator it, difference_type d) {
    it -= d;
    return it;
  }


  reference operator[](difference_type d) const { return *(*this + d); }


  difference_type operator-(const iterator& x) const { return it_ - x.it_; }

 private:
  template<typename OtherElement>
  friend class RepeatedPtrIterator;


  void** it_;
};


}

template <typename Element>
inline typename RepeatedPtrField<Element>::iterator
RepeatedPtrField<Element>::begin() {
  return iterator(raw_data());
}
template <typename Element>
inline typename RepeatedPtrField<Element>::const_iterator
RepeatedPtrField<Element>::begin() const {
  return iterator(raw_data());
}
template <typename Element>
inline typename RepeatedPtrField<Element>::iterator
RepeatedPtrField<Element>::end() {
  return iterator(raw_data() + size());
}
template <typename Element>
inline typename RepeatedPtrField<Element>::const_iterator
RepeatedPtrField<Element>::end() const {
  return iterator(raw_data() + size());
}

template <typename Element>
inline typename RepeatedPtrField<Element>::pointer_iterator
RepeatedPtrField<Element>::pointer_begin() {
  return pointer_iterator(raw_mutable_data());
}
template <typename Element>
inline typename RepeatedPtrField<Element>::pointer_iterator
RepeatedPtrField<Element>::pointer_end() {
  return pointer_iterator(raw_mutable_data() + size());
}
# 1178 "/usr/include/google/protobuf/repeated_field.h" 3 4
namespace internal {

template<typename T> class RepeatedFieldBackInsertIterator
    : public std::iterator<std::output_iterator_tag, T> {
 public:
  explicit RepeatedFieldBackInsertIterator(
      RepeatedField<T>* const mutable_field)
      : field_(mutable_field) {
  }
  RepeatedFieldBackInsertIterator<T>& operator=(const T& value) {
    field_->Add(value);
    return *this;
  }
  RepeatedFieldBackInsertIterator<T>& operator*() {
    return *this;
  }
  RepeatedFieldBackInsertIterator<T>& operator++() {
    return *this;
  }
  RepeatedFieldBackInsertIterator<T>& operator++(int ignores_parameter) {
    return *this;
  }

 private:
  RepeatedField<T>* field_;
};


template<typename T> class RepeatedPtrFieldBackInsertIterator
    : public std::iterator<std::output_iterator_tag, T> {
 public:
  RepeatedPtrFieldBackInsertIterator(
      RepeatedPtrField<T>* const mutable_field)
      : field_(mutable_field) {
  }
  RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value) {
    *field_->Add() = value;
    return *this;
  }
  RepeatedPtrFieldBackInsertIterator<T>& operator=(
      const T* const ptr_to_value) {
    *field_->Add() = *ptr_to_value;
    return *this;
  }
  RepeatedPtrFieldBackInsertIterator<T>& operator*() {
    return *this;
  }
  RepeatedPtrFieldBackInsertIterator<T>& operator++() {
    return *this;
  }
  RepeatedPtrFieldBackInsertIterator<T>& operator++(int ignores_parameter) {
    return *this;
  }

 private:
  RepeatedPtrField<T>* field_;
};



template<typename T> class AllocatedRepeatedPtrFieldBackInsertIterator
    : public std::iterator<std::output_iterator_tag, T> {
 public:
  explicit AllocatedRepeatedPtrFieldBackInsertIterator(
      RepeatedPtrField<T>* const mutable_field)
      : field_(mutable_field) {
  }
  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
      T* const ptr_to_value) {
    field_->AddAllocated(ptr_to_value);
    return *this;
  }
  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() {
    return *this;
  }
  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() {
    return *this;
  }
  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
      int ignores_parameter) {
    return *this;
  }

 private:
  RepeatedPtrField<T>* field_;
};
}




template<typename T> internal::RepeatedFieldBackInsertIterator<T>
RepeatedFieldBackInserter(RepeatedField<T>* const mutable_field) {
  return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
}




template<typename T> internal::RepeatedPtrFieldBackInsertIterator<T>
RepeatedFieldBackInserter(RepeatedPtrField<T>* const mutable_field) {
  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
}




template<typename T> internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
AllocatedRepeatedPtrFieldBackInserter(
    RepeatedPtrField<T>* const mutable_field) {
  return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
      mutable_field);
}

}

}
# 24 "./drizzled/message/table.pb.h" 2
# 1 "/usr/include/google/protobuf/extension_set.h" 1 3 4
# 49 "/usr/include/google/protobuf/extension_set.h" 3 4
namespace google {

namespace protobuf {
  class Descriptor;
  class FieldDescriptor;
  class DescriptorPool;
  class MessageLite;
  class Message;
  class MessageFactory;
  class UnknownFieldSet;
  namespace io {
    class CodedInputStream;
    class CodedOutputStream;
  }
  namespace internal {
    class FieldSkipper;
    class RepeatedPtrFieldBase;
  }
  template <typename Element> class RepeatedField;
  template <typename Element> class RepeatedPtrField;
}

namespace protobuf {
namespace internal {





typedef uint8 FieldType;




typedef bool EnumValidityFunc(int number);



typedef bool EnumValidityFuncWithArg(const void* arg, int number);


struct ExtensionInfo {
  inline ExtensionInfo() {}
  inline ExtensionInfo(FieldType type, bool is_repeated, bool is_packed)
      : type(type), is_repeated(is_repeated), is_packed(is_packed),
        descriptor(__null) {}

  FieldType type;
  bool is_repeated;
  bool is_packed;

  struct EnumValidityCheck {
    EnumValidityFuncWithArg* func;
    const void* arg;
  };

  union {
    EnumValidityCheck enum_validity_check;
    const MessageLite* message_prototype;
  };




  const FieldDescriptor* descriptor;
};



class ExtensionFinder {
 public:
  virtual ~ExtensionFinder();


  virtual bool Find(int number, ExtensionInfo* output) = 0;
};



class GeneratedExtensionFinder : public ExtensionFinder {
 public:
  GeneratedExtensionFinder(const MessageLite* containing_type)
      : containing_type_(containing_type) {}
  virtual ~GeneratedExtensionFinder() {}


  virtual bool Find(int number, ExtensionInfo* output);

 private:
  const MessageLite* containing_type_;
};
# 155 "/usr/include/google/protobuf/extension_set.h" 3 4
class ExtensionSet {
 public:
  ExtensionSet();
  ~ExtensionSet();






  static void RegisterExtension(const MessageLite* containing_type,
                                int number, FieldType type,
                                bool is_repeated, bool is_packed);
  static void RegisterEnumExtension(const MessageLite* containing_type,
                                    int number, FieldType type,
                                    bool is_repeated, bool is_packed,
                                    EnumValidityFunc* is_valid);
  static void RegisterMessageExtension(const MessageLite* containing_type,
                                       int number, FieldType type,
                                       bool is_repeated, bool is_packed,
                                       const MessageLite* prototype);





  void AppendToList(const Descriptor* containing_type,
                    const DescriptorPool* pool,
                    vector<const FieldDescriptor*>* output) const;
# 215 "/usr/include/google/protobuf/extension_set.h" 3 4
  bool Has(int number) const;
  int ExtensionSize(int number) const;
  FieldType ExtensionType(int number) const;
  void ClearExtension(int number);



  int32 GetInt32 (int number, int32 default_value) const;
  int64 GetInt64 (int number, int64 default_value) const;
  uint32 GetUInt32(int number, uint32 default_value) const;
  uint64 GetUInt64(int number, uint64 default_value) const;
  float GetFloat (int number, float default_value) const;
  double GetDouble(int number, double default_value) const;
  bool GetBool (int number, bool default_value) const;
  int GetEnum (int number, int default_value) const;
  const string & GetString (int number, const string& default_value) const;
  const MessageLite& GetMessage(int number,
                                const MessageLite& default_value) const;
  const MessageLite& GetMessage(int number, const Descriptor* message_type,
                                MessageFactory* factory) const;





  void SetInt32 (int number, FieldType type, int32 value, const FieldDescriptor* descriptor);
  void SetInt64 (int number, FieldType type, int64 value, const FieldDescriptor* descriptor);
  void SetUInt32(int number, FieldType type, uint32 value, const FieldDescriptor* descriptor);
  void SetUInt64(int number, FieldType type, uint64 value, const FieldDescriptor* descriptor);
  void SetFloat (int number, FieldType type, float value, const FieldDescriptor* descriptor);
  void SetDouble(int number, FieldType type, double value, const FieldDescriptor* descriptor);
  void SetBool (int number, FieldType type, bool value, const FieldDescriptor* descriptor);
  void SetEnum (int number, FieldType type, int value, const FieldDescriptor* descriptor);
  void SetString(int number, FieldType type, const string& value, const FieldDescriptor* descriptor);
  string * MutableString (int number, FieldType type, const FieldDescriptor* descriptor);
  MessageLite* MutableMessage(int number, FieldType type,
                              const MessageLite& prototype, const FieldDescriptor* descriptor);
  MessageLite* MutableMessage(const FieldDescriptor* decsriptor,
                              MessageFactory* factory);




  int32 GetRepeatedInt32 (int number, int index) const;
  int64 GetRepeatedInt64 (int number, int index) const;
  uint32 GetRepeatedUInt32(int number, int index) const;
  uint64 GetRepeatedUInt64(int number, int index) const;
  float GetRepeatedFloat (int number, int index) const;
  double GetRepeatedDouble(int number, int index) const;
  bool GetRepeatedBool (int number, int index) const;
  int GetRepeatedEnum (int number, int index) const;
  const string & GetRepeatedString (int number, int index) const;
  const MessageLite& GetRepeatedMessage(int number, int index) const;

  void SetRepeatedInt32 (int number, int index, int32 value);
  void SetRepeatedInt64 (int number, int index, int64 value);
  void SetRepeatedUInt32(int number, int index, uint32 value);
  void SetRepeatedUInt64(int number, int index, uint64 value);
  void SetRepeatedFloat (int number, int index, float value);
  void SetRepeatedDouble(int number, int index, double value);
  void SetRepeatedBool (int number, int index, bool value);
  void SetRepeatedEnum (int number, int index, int value);
  void SetRepeatedString(int number, int index, const string& value);
  string * MutableRepeatedString (int number, int index);
  MessageLite* MutableRepeatedMessage(int number, int index);


  void AddInt32 (int number, FieldType type, bool packed, int32 value, const FieldDescriptor* descriptor);
  void AddInt64 (int number, FieldType type, bool packed, int64 value, const FieldDescriptor* descriptor);
  void AddUInt32(int number, FieldType type, bool packed, uint32 value, const FieldDescriptor* descriptor);
  void AddUInt64(int number, FieldType type, bool packed, uint64 value, const FieldDescriptor* descriptor);
  void AddFloat (int number, FieldType type, bool packed, float value, const FieldDescriptor* descriptor);
  void AddDouble(int number, FieldType type, bool packed, double value, const FieldDescriptor* descriptor);
  void AddBool (int number, FieldType type, bool packed, bool value, const FieldDescriptor* descriptor);
  void AddEnum (int number, FieldType type, bool packed, int value, const FieldDescriptor* descriptor);
  void AddString(int number, FieldType type, const string& value, const FieldDescriptor* descriptor);
  string * AddString (int number, FieldType type, const FieldDescriptor* descriptor);
  MessageLite* AddMessage(int number, FieldType type,
                          const MessageLite& prototype, const FieldDescriptor* descriptor);
  MessageLite* AddMessage(const FieldDescriptor* descriptor,
                          MessageFactory* factory);


  void RemoveLast(int number);
  void SwapElements(int number, int index1, int index2);
# 310 "/usr/include/google/protobuf/extension_set.h" 3 4
  void Clear();
  void MergeFrom(const ExtensionSet& other);
  void Swap(ExtensionSet* other);
  bool IsInitialized() const;







  bool ParseField(uint32 tag, io::CodedInputStream* input,
                  ExtensionFinder* extension_finder,
                  FieldSkipper* field_skipper);



  bool ParseField(uint32 tag, io::CodedInputStream* input,
                  const MessageLite* containing_type);
  bool ParseField(uint32 tag, io::CodedInputStream* input,
                  const Message* containing_type,
                  UnknownFieldSet* unknown_fields);



  bool ParseMessageSet(io::CodedInputStream* input,
                       ExtensionFinder* extension_finder,
                       FieldSkipper* field_skipper);



  bool ParseMessageSet(io::CodedInputStream* input,
                       const MessageLite* containing_type);
  bool ParseMessageSet(io::CodedInputStream* input,
                       const Message* containing_type,
                       UnknownFieldSet* unknown_fields);





  void SerializeWithCachedSizes(int start_field_number,
                                int end_field_number,
                                io::CodedOutputStream* output) const;






  uint8* SerializeWithCachedSizesToArray(int start_field_number,
                                         int end_field_number,
                                         uint8* target) const;


  void SerializeMessageSetWithCachedSizes(io::CodedOutputStream* output) const;
  uint8* SerializeMessageSetWithCachedSizesToArray(uint8* target) const;


  int ByteSize() const;


  int MessageSetByteSize() const;
# 381 "/usr/include/google/protobuf/extension_set.h" 3 4
  int SpaceUsedExcludingSelf() const;

 private:

  struct Extension {
    union {
      int32 int32_value;
      int64 int64_value;
      uint32 uint32_value;
      uint64 uint64_value;
      float float_value;
      double double_value;
      bool bool_value;
      int enum_value;
      string* string_value;
      MessageLite* message_value;

      RepeatedField <int32 >* repeated_int32_value;
      RepeatedField <int64 >* repeated_int64_value;
      RepeatedField <uint32 >* repeated_uint32_value;
      RepeatedField <uint64 >* repeated_uint64_value;
      RepeatedField <float >* repeated_float_value;
      RepeatedField <double >* repeated_double_value;
      RepeatedField <bool >* repeated_bool_value;
      RepeatedField <int >* repeated_enum_value;
      RepeatedPtrField<string >* repeated_string_value;
      RepeatedPtrField<MessageLite>* repeated_message_value;
    };

    FieldType type;
    bool is_repeated;







    bool is_cleared;


    bool is_packed;




    const FieldDescriptor* descriptor;




    mutable int cached_size;


    void SerializeFieldWithCachedSizes(
        int number,
        io::CodedOutputStream* output) const;
    uint8* SerializeFieldWithCachedSizesToArray(
        int number,
        uint8* target) const;
    void SerializeMessageSetItemWithCachedSizes(
        int number,
        io::CodedOutputStream* output) const;
    uint8* SerializeMessageSetItemWithCachedSizesToArray(
        int number,
        uint8* target) const;
    int ByteSize(int number) const;
    int MessageSetItemByteSize(int number) const;
    void Clear();
    int GetSize() const;
    void Free();
    int SpaceUsedExcludingSelf() const;
  };




  bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
                         Extension** result);



  bool ParseMessageSetItem(io::CodedInputStream* input,
                           ExtensionFinder* extension_finder,
                           FieldSkipper* field_skipper);
# 475 "/usr/include/google/protobuf/extension_set.h" 3 4
  static inline int RepeatedMessage_SpaceUsedExcludingSelf(
      RepeatedPtrFieldBase* field);







  map<int, Extension> extensions_;

  ExtensionSet(const ExtensionSet&); void operator=(const ExtensionSet&);
};


inline void ExtensionSet::SetString(int number, FieldType type,
                                    const string& value,
                                    const FieldDescriptor* descriptor) {
  MutableString(number, type, descriptor)->assign(value);
}
inline void ExtensionSet::SetRepeatedString(int number, int index,
                                            const string& value) {
  MutableRepeatedString(number, index)->assign(value);
}
inline void ExtensionSet::AddString(int number, FieldType type,
                                    const string& value,
                                    const FieldDescriptor* descriptor) {
  AddString(number, type, descriptor)->assign(value);
}
# 554 "/usr/include/google/protobuf/extension_set.h" 3 4
template <typename Type>
class PrimitiveTypeTraits {
 public:
  typedef Type ConstType;

  static inline ConstType Get(int number, const ExtensionSet& set,
                              ConstType default_value);
  static inline void Set(int number, FieldType field_type,
                         ConstType value, ExtensionSet* set);
};

template <typename Type>
class RepeatedPrimitiveTypeTraits {
 public:
  typedef Type ConstType;

  static inline Type Get(int number, const ExtensionSet& set, int index);
  static inline void Set(int number, int index, Type value, ExtensionSet* set);
  static inline void Add(int number, FieldType field_type,
                         bool is_packed, Type value, ExtensionSet* set);
};
# 600 "/usr/include/google/protobuf/extension_set.h" 3 4
template<> inline int32 PrimitiveTypeTraits<int32>::Get( int number, const ExtensionSet& set, int32 default_value) { return set.GetInt32(number, default_value); } template<> inline void PrimitiveTypeTraits<int32>::Set( int number, FieldType field_type, int32 value, ExtensionSet* set) { set->SetInt32(number, field_type, value, __null); } template<> inline int32 RepeatedPrimitiveTypeTraits<int32>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedInt32(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<int32>::Set( int number, int index, int32 value, ExtensionSet* set) { set->SetRepeatedInt32(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<int32>::Add( int number, FieldType field_type, bool is_packed, int32 value, ExtensionSet* set) { set->AddInt32(number, field_type, is_packed, value, __null); }
template<> inline int64 PrimitiveTypeTraits<int64>::Get( int number, const ExtensionSet& set, int64 default_value) { return set.GetInt64(number, default_value); } template<> inline void PrimitiveTypeTraits<int64>::Set( int number, FieldType field_type, int64 value, ExtensionSet* set) { set->SetInt64(number, field_type, value, __null); } template<> inline int64 RepeatedPrimitiveTypeTraits<int64>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedInt64(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<int64>::Set( int number, int index, int64 value, ExtensionSet* set) { set->SetRepeatedInt64(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<int64>::Add( int number, FieldType field_type, bool is_packed, int64 value, ExtensionSet* set) { set->AddInt64(number, field_type, is_packed, value, __null); }
template<> inline uint32 PrimitiveTypeTraits<uint32>::Get( int number, const ExtensionSet& set, uint32 default_value) { return set.GetUInt32(number, default_value); } template<> inline void PrimitiveTypeTraits<uint32>::Set( int number, FieldType field_type, uint32 value, ExtensionSet* set) { set->SetUInt32(number, field_type, value, __null); } template<> inline uint32 RepeatedPrimitiveTypeTraits<uint32>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedUInt32(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<uint32>::Set( int number, int index, uint32 value, ExtensionSet* set) { set->SetRepeatedUInt32(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<uint32>::Add( int number, FieldType field_type, bool is_packed, uint32 value, ExtensionSet* set) { set->AddUInt32(number, field_type, is_packed, value, __null); }
template<> inline uint64 PrimitiveTypeTraits<uint64>::Get( int number, const ExtensionSet& set, uint64 default_value) { return set.GetUInt64(number, default_value); } template<> inline void PrimitiveTypeTraits<uint64>::Set( int number, FieldType field_type, uint64 value, ExtensionSet* set) { set->SetUInt64(number, field_type, value, __null); } template<> inline uint64 RepeatedPrimitiveTypeTraits<uint64>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedUInt64(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<uint64>::Set( int number, int index, uint64 value, ExtensionSet* set) { set->SetRepeatedUInt64(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<uint64>::Add( int number, FieldType field_type, bool is_packed, uint64 value, ExtensionSet* set) { set->AddUInt64(number, field_type, is_packed, value, __null); }
template<> inline float PrimitiveTypeTraits<float>::Get( int number, const ExtensionSet& set, float default_value) { return set.GetFloat(number, default_value); } template<> inline void PrimitiveTypeTraits<float>::Set( int number, FieldType field_type, float value, ExtensionSet* set) { set->SetFloat(number, field_type, value, __null); } template<> inline float RepeatedPrimitiveTypeTraits<float>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedFloat(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<float>::Set( int number, int index, float value, ExtensionSet* set) { set->SetRepeatedFloat(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<float>::Add( int number, FieldType field_type, bool is_packed, float value, ExtensionSet* set) { set->AddFloat(number, field_type, is_packed, value, __null); }
template<> inline double PrimitiveTypeTraits<double>::Get( int number, const ExtensionSet& set, double default_value) { return set.GetDouble(number, default_value); } template<> inline void PrimitiveTypeTraits<double>::Set( int number, FieldType field_type, double value, ExtensionSet* set) { set->SetDouble(number, field_type, value, __null); } template<> inline double RepeatedPrimitiveTypeTraits<double>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedDouble(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<double>::Set( int number, int index, double value, ExtensionSet* set) { set->SetRepeatedDouble(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<double>::Add( int number, FieldType field_type, bool is_packed, double value, ExtensionSet* set) { set->AddDouble(number, field_type, is_packed, value, __null); }
template<> inline bool PrimitiveTypeTraits<bool>::Get( int number, const ExtensionSet& set, bool default_value) { return set.GetBool(number, default_value); } template<> inline void PrimitiveTypeTraits<bool>::Set( int number, FieldType field_type, bool value, ExtensionSet* set) { set->SetBool(number, field_type, value, __null); } template<> inline bool RepeatedPrimitiveTypeTraits<bool>::Get( int number, const ExtensionSet& set, int index) { return set.GetRepeatedBool(number, index); } template<> inline void RepeatedPrimitiveTypeTraits<bool>::Set( int number, int index, bool value, ExtensionSet* set) { set->SetRepeatedBool(number, index, value); } template<> inline void RepeatedPrimitiveTypeTraits<bool>::Add( int number, FieldType field_type, bool is_packed, bool value, ExtensionSet* set) { set->AddBool(number, field_type, is_packed, value, __null); }







class StringTypeTraits {
 public:
  typedef const string& ConstType;
  typedef string* MutableType;

  static inline const string& Get(int number, const ExtensionSet& set,
                                  ConstType default_value) {
    return set.GetString(number, default_value);
  }
  static inline void Set(int number, FieldType field_type,
                         const string& value, ExtensionSet* set) {
    set->SetString(number, field_type, value, __null);
  }
  static inline string* Mutable(int number, FieldType field_type,
                                ExtensionSet* set) {
    return set->MutableString(number, field_type, __null);
  }
};

class RepeatedStringTypeTraits {
 public:
  typedef const string& ConstType;
  typedef string* MutableType;

  static inline const string& Get(int number, const ExtensionSet& set,
                                  int index) {
    return set.GetRepeatedString(number, index);
  }
  static inline void Set(int number, int index,
                         const string& value, ExtensionSet* set) {
    set->SetRepeatedString(number, index, value);
  }
  static inline string* Mutable(int number, int index, ExtensionSet* set) {
    return set->MutableRepeatedString(number, index);
  }
  static inline void Add(int number, FieldType field_type,
                         bool , const string& value,
                         ExtensionSet* set) {
    set->AddString(number, field_type, value, __null);
  }
  static inline string* Add(int number, FieldType field_type,
                            ExtensionSet* set) {
    return set->AddString(number, field_type, __null);
  }
};






template <typename Type, bool IsValid(int)>
class EnumTypeTraits {
 public:
  typedef Type ConstType;

  static inline ConstType Get(int number, const ExtensionSet& set,
                              ConstType default_value) {
    return static_cast<Type>(set.GetEnum(number, default_value));
  }
  static inline void Set(int number, FieldType field_type,
                         ConstType value, ExtensionSet* set) {
    !(!(IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/extension_set.h", 676) << "CHECK failed: " "IsValid(value)" ": ";
    set->SetEnum(number, field_type, value, __null);
  }
};

template <typename Type, bool IsValid(int)>
class RepeatedEnumTypeTraits {
 public:
  typedef Type ConstType;

  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
    return static_cast<Type>(set.GetRepeatedEnum(number, index));
  }
  static inline void Set(int number, int index,
                         ConstType value, ExtensionSet* set) {
    !(!(IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/extension_set.h", 691) << "CHECK failed: " "IsValid(value)" ": ";
    set->SetRepeatedEnum(number, index, value);
  }
  static inline void Add(int number, FieldType field_type,
                         bool is_packed, ConstType value, ExtensionSet* set) {
    !(!(IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/extension_set.h", 696) << "CHECK failed: " "IsValid(value)" ": ";
    set->AddEnum(number, field_type, is_packed, value, __null);
  }
};







template <typename Type>
class MessageTypeTraits {
 public:
  typedef const Type& ConstType;
  typedef Type* MutableType;

  static inline ConstType Get(int number, const ExtensionSet& set,
                              ConstType default_value) {
    return static_cast<const Type&>(
        set.GetMessage(number, default_value));
  }
  static inline MutableType Mutable(int number, FieldType field_type,
                                    ExtensionSet* set) {
    return static_cast<Type*>(
      set->MutableMessage(number, field_type, Type::default_instance(), __null));
  }
};

template <typename Type>
class RepeatedMessageTypeTraits {
 public:
  typedef const Type& ConstType;
  typedef Type* MutableType;

  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
    return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
  }
  static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
    return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
  }
  static inline MutableType Add(int number, FieldType field_type,
                                ExtensionSet* set) {
    return static_cast<Type*>(
        set->AddMessage(number, field_type, Type::default_instance(), __null));
  }
};
# 761 "/usr/include/google/protobuf/extension_set.h" 3 4
template <typename ExtendeeType, typename TypeTraitsType,
          FieldType field_type, bool is_packed>
class ExtensionIdentifier {
 public:
  typedef TypeTraitsType TypeTraits;
  typedef ExtendeeType Extendee;

  ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value)
      : number_(number), default_value_(default_value) {}
  inline int number() const { return number_; }
  typename TypeTraits::ConstType default_value() const {
    return default_value_;
  }

 private:
  const int number_;
  typename TypeTraits::ConstType default_value_;
};
# 900 "/usr/include/google/protobuf/extension_set.h" 3 4
}
}

}
# 25 "./drizzled/message/table.pb.h" 2
# 1 "/usr/include/google/protobuf/generated_message_reflection.h" 1 3 4
# 43 "/usr/include/google/protobuf/generated_message_reflection.h" 3 4
# 1 "/usr/include/google/protobuf/message.h" 1 3 4
# 127 "/usr/include/google/protobuf/message.h" 3 4
namespace google {
namespace protobuf {


class Message;
class Reflection;
class MessageFactory;


class Descriptor;
class FieldDescriptor;
class EnumDescriptor;
class EnumValueDescriptor;
namespace io {
  class ZeroCopyInputStream;
  class ZeroCopyOutputStream;
  class CodedInputStream;
  class CodedOutputStream;
}
class UnknownFieldSet;


struct Metadata {
  const Descriptor* descriptor;
  const Reflection* reflection;
};




template <typename E>
const EnumDescriptor* GetEnumDescriptor();
# 170 "/usr/include/google/protobuf/message.h" 3 4
class Message : public MessageLite {
 public:
  inline Message() {}
  virtual ~Message();






  virtual Message* New() const = 0;




  virtual void CopyFrom(const Message& from);





  virtual void MergeFrom(const Message& from);



  void CheckInitialized() const;





  void FindInitializationErrors(vector<string>* errors) const;



  string InitializationErrorString() const;
# 217 "/usr/include/google/protobuf/message.h" 3 4
  virtual void DiscardUnknownFields();




  virtual int SpaceUsed() const;





  string DebugString() const;

  string ShortDebugString() const;

  string Utf8DebugString() const;

  void PrintDebugString() const;







  bool ParseFromFileDescriptor(int file_descriptor);


  bool ParsePartialFromFileDescriptor(int file_descriptor);


  bool ParseFromIstream(istream* input);


  bool ParsePartialFromIstream(istream* input);



  bool SerializeToFileDescriptor(int file_descriptor) const;

  bool SerializePartialToFileDescriptor(int file_descriptor) const;


  bool SerializeToOstream(ostream* output) const;

  bool SerializePartialToOstream(ostream* output) const;






  virtual string GetTypeName() const;
  virtual void Clear();
  virtual bool IsInitialized() const;
  virtual void CheckTypeAndMergeFrom(const MessageLite& other);
  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input);
  virtual int ByteSize() const;
  virtual void SerializeWithCachedSizes(io::CodedOutputStream* output) const;

 private:







  virtual void SetCachedSize(int size) const;

 public:




  typedef google::protobuf::Reflection Reflection;



  const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; }
# 305 "/usr/include/google/protobuf/message.h" 3 4
  virtual const Reflection* GetReflection() const {
    return GetMetadata().reflection;
  }

 protected:



  virtual Metadata GetMetadata() const = 0;


 private:
  Message(const Message&); void operator=(const Message&);
};
# 361 "/usr/include/google/protobuf/message.h" 3 4
class Reflection {
 public:

  inline Reflection() {}
  virtual ~Reflection();




  virtual const UnknownFieldSet& GetUnknownFields(
      const Message& message) const = 0;



  virtual UnknownFieldSet* MutableUnknownFields(Message* message) const = 0;


  virtual int SpaceUsed(const Message& message) const = 0;


  virtual bool HasField(const Message& message,
                        const FieldDescriptor* field) const = 0;


  virtual int FieldSize(const Message& message,
                        const FieldDescriptor* field) const = 0;



  virtual void ClearField(Message* message,
                          const FieldDescriptor* field) const = 0;
# 400 "/usr/include/google/protobuf/message.h" 3 4
  virtual void RemoveLast(Message* message,
                          const FieldDescriptor* field) const = 0;


  virtual void Swap(Message* message1, Message* message2) const = 0;


  virtual void SwapElements(Message* message,
                    const FieldDescriptor* field,
                    int index1,
                    int index2) const = 0;






  virtual void ListFields(const Message& message,
                          vector<const FieldDescriptor*>* output) const = 0;





  virtual int32 GetInt32 (const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual int64 GetInt64 (const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual uint32 GetUInt32(const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual uint64 GetUInt64(const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual float GetFloat (const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual double GetDouble(const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual bool GetBool (const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual string GetString(const Message& message,
                           const FieldDescriptor* field) const = 0;
  virtual const EnumValueDescriptor* GetEnum(
      const Message& message, const FieldDescriptor* field) const = 0;

  virtual const Message& GetMessage(const Message& message,
                                    const FieldDescriptor* field,
                                    MessageFactory* factory = __null) const = 0;
# 462 "/usr/include/google/protobuf/message.h" 3 4
  virtual const string& GetStringReference(const Message& message,
                                           const FieldDescriptor* field,
                                           string* scratch) const = 0;





  virtual void SetInt32 (Message* message,
                         const FieldDescriptor* field, int32 value) const = 0;
  virtual void SetInt64 (Message* message,
                         const FieldDescriptor* field, int64 value) const = 0;
  virtual void SetUInt32(Message* message,
                         const FieldDescriptor* field, uint32 value) const = 0;
  virtual void SetUInt64(Message* message,
                         const FieldDescriptor* field, uint64 value) const = 0;
  virtual void SetFloat (Message* message,
                         const FieldDescriptor* field, float value) const = 0;
  virtual void SetDouble(Message* message,
                         const FieldDescriptor* field, double value) const = 0;
  virtual void SetBool (Message* message,
                         const FieldDescriptor* field, bool value) const = 0;
  virtual void SetString(Message* message,
                         const FieldDescriptor* field,
                         const string& value) const = 0;
  virtual void SetEnum (Message* message,
                         const FieldDescriptor* field,
                         const EnumValueDescriptor* value) const = 0;
# 500 "/usr/include/google/protobuf/message.h" 3 4
  virtual Message* MutableMessage(Message* message,
                                  const FieldDescriptor* field,
                                  MessageFactory* factory = __null) const = 0;





  virtual int32 GetRepeatedInt32 (const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual int64 GetRepeatedInt64 (const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual uint32 GetRepeatedUInt32(const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual uint64 GetRepeatedUInt64(const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual float GetRepeatedFloat (const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual double GetRepeatedDouble(const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual bool GetRepeatedBool (const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual string GetRepeatedString(const Message& message,
                                   const FieldDescriptor* field,
                                   int index) const = 0;
  virtual const EnumValueDescriptor* GetRepeatedEnum(
      const Message& message,
      const FieldDescriptor* field, int index) const = 0;
  virtual const Message& GetRepeatedMessage(
      const Message& message,
      const FieldDescriptor* field, int index) const = 0;


  virtual const string& GetRepeatedStringReference(
      const Message& message, const FieldDescriptor* field,
      int index, string* scratch) const = 0;





  virtual void SetRepeatedInt32 (Message* message,
                                 const FieldDescriptor* field,
                                 int index, int32 value) const = 0;
  virtual void SetRepeatedInt64 (Message* message,
                                 const FieldDescriptor* field,
                                 int index, int64 value) const = 0;
  virtual void SetRepeatedUInt32(Message* message,
                                 const FieldDescriptor* field,
                                 int index, uint32 value) const = 0;
  virtual void SetRepeatedUInt64(Message* message,
                                 const FieldDescriptor* field,
                                 int index, uint64 value) const = 0;
  virtual void SetRepeatedFloat (Message* message,
                                 const FieldDescriptor* field,
                                 int index, float value) const = 0;
  virtual void SetRepeatedDouble(Message* message,
                                 const FieldDescriptor* field,
                                 int index, double value) const = 0;
  virtual void SetRepeatedBool (Message* message,
                                 const FieldDescriptor* field,
                                 int index, bool value) const = 0;
  virtual void SetRepeatedString(Message* message,
                                 const FieldDescriptor* field,
                                 int index, const string& value) const = 0;
  virtual void SetRepeatedEnum(Message* message,
                               const FieldDescriptor* field, int index,
                               const EnumValueDescriptor* value) const = 0;


  virtual Message* MutableRepeatedMessage(
      Message* message, const FieldDescriptor* field, int index) const = 0;





  virtual void AddInt32 (Message* message,
                         const FieldDescriptor* field, int32 value) const = 0;
  virtual void AddInt64 (Message* message,
                         const FieldDescriptor* field, int64 value) const = 0;
  virtual void AddUInt32(Message* message,
                         const FieldDescriptor* field, uint32 value) const = 0;
  virtual void AddUInt64(Message* message,
                         const FieldDescriptor* field, uint64 value) const = 0;
  virtual void AddFloat (Message* message,
                         const FieldDescriptor* field, float value) const = 0;
  virtual void AddDouble(Message* message,
                         const FieldDescriptor* field, double value) const = 0;
  virtual void AddBool (Message* message,
                         const FieldDescriptor* field, bool value) const = 0;
  virtual void AddString(Message* message,
                         const FieldDescriptor* field,
                         const string& value) const = 0;
  virtual void AddEnum (Message* message,
                         const FieldDescriptor* field,
                         const EnumValueDescriptor* value) const = 0;

  virtual Message* AddMessage(Message* message,
                              const FieldDescriptor* field,
                              MessageFactory* factory = __null) const = 0;






  virtual const FieldDescriptor* FindKnownExtensionByName(
      const string& name) const = 0;



  virtual const FieldDescriptor* FindKnownExtensionByNumber(
      int number) const = 0;

 private:
  Reflection(const Reflection&); void operator=(const Reflection&);
};


class MessageFactory {
 public:
  inline MessageFactory() {}
  virtual ~MessageFactory();
# 650 "/usr/include/google/protobuf/message.h" 3 4
  virtual const Message* GetPrototype(const Descriptor* type) = 0;
# 666 "/usr/include/google/protobuf/message.h" 3 4
  static MessageFactory* generated_factory();
# 676 "/usr/include/google/protobuf/message.h" 3 4
  static void InternalRegisterGeneratedFile(
      const char* filename, void (*register_messages)(const string&));




  static void InternalRegisterGeneratedMessage(const Descriptor* descriptor,
                                               const Message* prototype);

 private:
  MessageFactory(const MessageFactory&); void operator=(const MessageFactory&);
};

}

}
# 44 "/usr/include/google/protobuf/generated_message_reflection.h" 2 3 4
# 1 "/usr/include/google/protobuf/unknown_field_set.h" 1 3 4
# 45 "/usr/include/google/protobuf/unknown_field_set.h" 3 4
namespace google {
namespace protobuf {

class Message;
class UnknownField;
# 63 "/usr/include/google/protobuf/unknown_field_set.h" 3 4
class UnknownFieldSet {
 public:
  UnknownFieldSet();
  ~UnknownFieldSet();


  inline void Clear();


  inline bool empty() const;


  void MergeFrom(const UnknownFieldSet& other);


  inline void Swap(UnknownFieldSet* x);




  int SpaceUsedExcludingSelf() const;


  int SpaceUsed() const;


  inline int field_count() const;


  inline const UnknownField& field(int index) const;



  inline UnknownField* mutable_field(int index);



  void AddVarint(int number, uint64 value);
  void AddFixed32(int number, uint32 value);
  void AddFixed64(int number, uint64 value);
  void AddLengthDelimited(int number, const string& value);
  string* AddLengthDelimited(int number);
  UnknownFieldSet* AddGroup(int number);


  void AddField(const UnknownField& field);




  bool MergeFromCodedStream(io::CodedInputStream* input);
  bool ParseFromCodedStream(io::CodedInputStream* input);
  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
  bool ParseFromArray(const void* data, int size);
  inline bool ParseFromString(const string& data) {
    return ParseFromArray(data.data(), data.size());
  }

 private:
  void ClearFallback();

  vector<UnknownField>* fields_;

  UnknownFieldSet(const UnknownFieldSet&); void operator=(const UnknownFieldSet&);
};


class UnknownField {
 public:
  enum Type {
    TYPE_VARINT,
    TYPE_FIXED32,
    TYPE_FIXED64,
    TYPE_LENGTH_DELIMITED,
    TYPE_GROUP
  };


  inline int number() const;


  inline Type type() const;




  inline uint64 varint() const;
  inline uint32 fixed32() const;
  inline uint64 fixed64() const;
  inline const string& length_delimited() const;
  inline const UnknownFieldSet& group() const;

  inline void set_varint(uint64 value);
  inline void set_fixed32(uint32 value);
  inline void set_fixed64(uint64 value);
  inline void set_length_delimited(const string& value);
  inline string* mutable_length_delimited();
  inline UnknownFieldSet* mutable_group();

 private:
  friend class UnknownFieldSet;


  void Delete();


  void DeepCopy();

  unsigned int number_ : 29;
  unsigned int type_ : 3;
  union {
    uint64 varint_;
    uint32 fixed32_;
    uint64 fixed64_;
    string* length_delimited_;
    UnknownFieldSet* group_;
  };
};




inline void UnknownFieldSet::Clear() {
  if (fields_ != __null) {
    ClearFallback();
  }
}

inline bool UnknownFieldSet::empty() const {
  return fields_ == __null || fields_->empty();
}

inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
  std::swap(fields_, x->fields_);
}

inline int UnknownFieldSet::field_count() const {
  return (fields_ == __null) ? 0 : fields_->size();
}
inline const UnknownField& UnknownFieldSet::field(int index) const {
  return (*fields_)[index];
}
inline UnknownField* UnknownFieldSet::mutable_field(int index) {
  return &(*fields_)[index];
}

inline void UnknownFieldSet::AddLengthDelimited(
    int number, const string& value) {
  AddLengthDelimited(number)->assign(value);
}

inline int UnknownField::number() const { return number_; }
inline UnknownField::Type UnknownField::type() const {
  return static_cast<Type>(type_);
}

inline uint64 UnknownField::varint () const {
  !(!((type_) == (TYPE_VARINT))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 220) << "CHECK failed: " "(type_) == (TYPE_VARINT)" ": ";
  return varint_;
}
inline uint32 UnknownField::fixed32() const {
  !(!((type_) == (TYPE_FIXED32))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 224) << "CHECK failed: " "(type_) == (TYPE_FIXED32)" ": ";
  return fixed32_;
}
inline uint64 UnknownField::fixed64() const {
  !(!((type_) == (TYPE_FIXED64))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 228) << "CHECK failed: " "(type_) == (TYPE_FIXED64)" ": ";
  return fixed64_;
}
inline const string& UnknownField::length_delimited() const {
  !(!((type_) == (TYPE_LENGTH_DELIMITED))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 232) << "CHECK failed: " "(type_) == (TYPE_LENGTH_DELIMITED)" ": ";
  return *length_delimited_;
}
inline const UnknownFieldSet& UnknownField::group() const {
  !(!((type_) == (TYPE_GROUP))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 236) << "CHECK failed: " "(type_) == (TYPE_GROUP)" ": ";
  return *group_;
}

inline void UnknownField::set_varint(uint64 value) {
  !(!((type_) == (TYPE_VARINT))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 241) << "CHECK failed: " "(type_) == (TYPE_VARINT)" ": ";
  varint_ = value;
}
inline void UnknownField::set_fixed32(uint32 value) {
  !(!((type_) == (TYPE_FIXED32))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 245) << "CHECK failed: " "(type_) == (TYPE_FIXED32)" ": ";
  fixed32_ = value;
}
inline void UnknownField::set_fixed64(uint64 value) {
  !(!((type_) == (TYPE_FIXED64))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 249) << "CHECK failed: " "(type_) == (TYPE_FIXED64)" ": ";
  fixed64_ = value;
}
inline void UnknownField::set_length_delimited(const string& value) {
  !(!((type_) == (TYPE_LENGTH_DELIMITED))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 253) << "CHECK failed: " "(type_) == (TYPE_LENGTH_DELIMITED)" ": ";
  length_delimited_->assign(value);
}
inline string* UnknownField::mutable_length_delimited() {
  !(!((type_) == (TYPE_LENGTH_DELIMITED))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 257) << "CHECK failed: " "(type_) == (TYPE_LENGTH_DELIMITED)" ": ";
  return length_delimited_;
}
inline UnknownFieldSet* UnknownField::mutable_group() {
  !(!((type_) == (TYPE_GROUP))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "/usr/include/google/protobuf/unknown_field_set.h", 261) << "CHECK failed: " "(type_) == (TYPE_GROUP)" ": ";
  return group_;
}

}

}
# 45 "/usr/include/google/protobuf/generated_message_reflection.h" 2 3 4


namespace google {
namespace protobuf {
  class DescriptorPool;


  class FileDescriptor;
  class EnumDescriptor;
}

namespace protobuf {
namespace internal {


class GeneratedMessageReflection;


class ExtensionSet;
# 89 "/usr/include/google/protobuf/generated_message_reflection.h" 3 4
class GeneratedMessageReflection : public Reflection {
 public:
# 122 "/usr/include/google/protobuf/generated_message_reflection.h" 3 4
  GeneratedMessageReflection(const Descriptor* descriptor,
                             const Message* default_instance,
                             const int offsets[],
                             int has_bits_offset,
                             int unknown_fields_offset,
                             int extensions_offset,
                             const DescriptorPool* pool,
                             MessageFactory* factory,
                             int object_size);
  ~GeneratedMessageReflection();



  const UnknownFieldSet& GetUnknownFields(const Message& message) const;
  UnknownFieldSet* MutableUnknownFields(Message* message) const;

  int SpaceUsed(const Message& message) const;

  bool HasField(const Message& message, const FieldDescriptor* field) const;
  int FieldSize(const Message& message, const FieldDescriptor* field) const;
  void ClearField(Message* message, const FieldDescriptor* field) const;
  void RemoveLast(Message* message, const FieldDescriptor* field) const;
  void Swap(Message* message1, Message* message2) const;
  void SwapElements(Message* message, const FieldDescriptor* field,
            int index1, int index2) const;
  void ListFields(const Message& message,
                  vector<const FieldDescriptor*>* output) const;

  int32 GetInt32 (const Message& message,
                   const FieldDescriptor* field) const;
  int64 GetInt64 (const Message& message,
                   const FieldDescriptor* field) const;
  uint32 GetUInt32(const Message& message,
                   const FieldDescriptor* field) const;
  uint64 GetUInt64(const Message& message,
                   const FieldDescriptor* field) const;
  float GetFloat (const Message& message,
                   const FieldDescriptor* field) const;
  double GetDouble(const Message& message,
                   const FieldDescriptor* field) const;
  bool GetBool (const Message& message,
                   const FieldDescriptor* field) const;
  string GetString(const Message& message,
                   const FieldDescriptor* field) const;
  const string& GetStringReference(const Message& message,
                                   const FieldDescriptor* field,
                                   string* scratch) const;
  const EnumValueDescriptor* GetEnum(const Message& message,
                                     const FieldDescriptor* field) const;
  const Message& GetMessage(const Message& message,
                            const FieldDescriptor* field,
                            MessageFactory* factory = __null) const;

  void SetInt32 (Message* message,
                 const FieldDescriptor* field, int32 value) const;
  void SetInt64 (Message* message,
                 const FieldDescriptor* field, int64 value) const;
  void SetUInt32(Message* message,
                 const FieldDescriptor* field, uint32 value) const;
  void SetUInt64(Message* message,
                 const FieldDescriptor* field, uint64 value) const;
  void SetFloat (Message* message,
                 const FieldDescriptor* field, float value) const;
  void SetDouble(Message* message,
                 const FieldDescriptor* field, double value) const;
  void SetBool (Message* message,
                 const FieldDescriptor* field, bool value) const;
  void SetString(Message* message,
                 const FieldDescriptor* field,
                 const string& value) const;
  void SetEnum (Message* message, const FieldDescriptor* field,
                 const EnumValueDescriptor* value) const;
  Message* MutableMessage(Message* message, const FieldDescriptor* field,
                          MessageFactory* factory = __null) const;

  int32 GetRepeatedInt32 (const Message& message,
                           const FieldDescriptor* field, int index) const;
  int64 GetRepeatedInt64 (const Message& message,
                           const FieldDescriptor* field, int index) const;
  uint32 GetRepeatedUInt32(const Message& message,
                           const FieldDescriptor* field, int index) const;
  uint64 GetRepeatedUInt64(const Message& message,
                           const FieldDescriptor* field, int index) const;
  float GetRepeatedFloat (const Message& message,
                           const FieldDescriptor* field, int index) const;
  double GetRepeatedDouble(const Message& message,
                           const FieldDescriptor* field, int index) const;
  bool GetRepeatedBool (const Message& message,
                           const FieldDescriptor* field, int index) const;
  string GetRepeatedString(const Message& message,
                           const FieldDescriptor* field, int index) const;
  const string& GetRepeatedStringReference(const Message& message,
                                           const FieldDescriptor* field,
                                           int index, string* scratch) const;
  const EnumValueDescriptor* GetRepeatedEnum(const Message& message,
                                             const FieldDescriptor* field,
                                             int index) const;
  const Message& GetRepeatedMessage(const Message& message,
                                    const FieldDescriptor* field,
                                    int index) const;


  void SetRepeatedInt32 (Message* message,
                         const FieldDescriptor* field, int index, int32 value) const;
  void SetRepeatedInt64 (Message* message,
                         const FieldDescriptor* field, int index, int64 value) const;
  void SetRepeatedUInt32(Message* message,
                         const FieldDescriptor* field, int index, uint32 value) const;
  void SetRepeatedUInt64(Message* message,
                         const FieldDescriptor* field, int index, uint64 value) const;
  void SetRepeatedFloat (Message* message,
                         const FieldDescriptor* field, int index, float value) const;
  void SetRepeatedDouble(Message* message,
                         const FieldDescriptor* field, int index, double value) const;
  void SetRepeatedBool (Message* message,
                         const FieldDescriptor* field, int index, bool value) const;
  void SetRepeatedString(Message* message,
                         const FieldDescriptor* field, int index,
                         const string& value) const;
  void SetRepeatedEnum(Message* message, const FieldDescriptor* field,
                       int index, const EnumValueDescriptor* value) const;

  Message* MutableRepeatedMessage(Message* message,
                                  const FieldDescriptor* field,
                                  int index) const;

  void AddInt32 (Message* message,
                 const FieldDescriptor* field, int32 value) const;
  void AddInt64 (Message* message,
                 const FieldDescriptor* field, int64 value) const;
  void AddUInt32(Message* message,
                 const FieldDescriptor* field, uint32 value) const;
  void AddUInt64(Message* message,
                 const FieldDescriptor* field, uint64 value) const;
  void AddFloat (Message* message,
                 const FieldDescriptor* field, float value) const;
  void AddDouble(Message* message,
                 const FieldDescriptor* field, double value) const;
  void AddBool (Message* message,
                 const FieldDescriptor* field, bool value) const;
  void AddString(Message* message,
                 const FieldDescriptor* field, const string& value) const;
  void AddEnum(Message* message,
               const FieldDescriptor* field,
               const EnumValueDescriptor* value) const;
  Message* AddMessage(Message* message, const FieldDescriptor* field,
                      MessageFactory* factory = __null) const;

  const FieldDescriptor* FindKnownExtensionByName(const string& name) const;
  const FieldDescriptor* FindKnownExtensionByNumber(int number) const;

 private:
  friend class GeneratedMessage;

  const Descriptor* descriptor_;
  const Message* default_instance_;
  const int* offsets_;

  int has_bits_offset_;
  int unknown_fields_offset_;
  int extensions_offset_;
  int object_size_;

  const DescriptorPool* descriptor_pool_;
  MessageFactory* message_factory_;

  template <typename Type>
  inline const Type& GetRaw(const Message& message,
                            const FieldDescriptor* field) const;
  template <typename Type>
  inline Type* MutableRaw(Message* message,
                          const FieldDescriptor* field) const;
  template <typename Type>
  inline const Type& DefaultRaw(const FieldDescriptor* field) const;
  inline const Message* GetMessagePrototype(const FieldDescriptor* field) const;

  inline const uint32* GetHasBits(const Message& message) const;
  inline uint32* MutableHasBits(Message* message) const;
  inline const ExtensionSet& GetExtensionSet(const Message& message) const;
  inline ExtensionSet* MutableExtensionSet(Message* message) const;

  inline bool HasBit(const Message& message,
                     const FieldDescriptor* field) const;
  inline void SetBit(Message* message,
                     const FieldDescriptor* field) const;
  inline void ClearBit(Message* message,
                       const FieldDescriptor* field) const;

  template <typename Type>
  inline const Type& GetField(const Message& message,
                              const FieldDescriptor* field) const;
  template <typename Type>
  inline void SetField(Message* message,
                       const FieldDescriptor* field, const Type& value) const;
  template <typename Type>
  inline Type* MutableField(Message* message,
                            const FieldDescriptor* field) const;
  template <typename Type>
  inline const Type& GetRepeatedField(const Message& message,
                                      const FieldDescriptor* field,
                                      int index) const;
  template <typename Type>
  inline const Type& GetRepeatedPtrField(const Message& message,
                                         const FieldDescriptor* field,
                                         int index) const;
  template <typename Type>
  inline void SetRepeatedField(Message* message,
                               const FieldDescriptor* field, int index,
                               Type value) const;
  template <typename Type>
  inline Type* MutableRepeatedField(Message* message,
                                    const FieldDescriptor* field,
                                    int index) const;
  template <typename Type>
  inline void AddField(Message* message,
                       const FieldDescriptor* field, const Type& value) const;
  template <typename Type>
  inline Type* AddField(Message* message,
                        const FieldDescriptor* field) const;

  int GetExtensionNumberOrDie(const Descriptor* type) const;

  GeneratedMessageReflection(const GeneratedMessageReflection&); void operator=(const GeneratedMessageReflection&);
};
# 389 "/usr/include/google/protobuf/generated_message_reflection.h" 3 4
template<typename To, typename From>
inline To dynamic_cast_if_available(From from) {



  return dynamic_cast<To>(from);

}




 bool ParseNamedEnum(const EnumDescriptor* descriptor,
                    const string& name,
                    int* value);

template<typename EnumType>
bool ParseNamedEnum(const EnumDescriptor* descriptor,
                    const string& name,
                    EnumType* value) {
  int tmp;
  if (!ParseNamedEnum(descriptor, name, &tmp)) return false;
  *value = static_cast<EnumType>(tmp);
  return true;
}




 const string& NameOfEnum(const EnumDescriptor* descriptor, int value);

}
}

}
# 26 "./drizzled/message/table.pb.h" 2
# 1 "./drizzled/message/engine.pb.h" 1
# 28 "./drizzled/message/engine.pb.h"
namespace drizzled {
namespace message {


void protobuf_AddDesc_engine_2eproto();
void protobuf_AssignDesc_engine_2eproto();
void protobuf_ShutdownFile_engine_2eproto();

class Engine;
class Engine_Option;



class Engine_Option : public ::google::protobuf::Message {
 public:
  Engine_Option();
  virtual ~Engine_Option();

  Engine_Option(const Engine_Option& from);

  inline Engine_Option& operator=(const Engine_Option& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Engine_Option& default_instance();

  void Swap(Engine_Option* other);



  Engine_Option* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Engine_Option& from);
  void MergeFrom(const Engine_Option& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 2;
  inline const ::std::string& state() const;
  inline void set_state(const ::std::string& value);
  inline void set_state(const char* value);
  inline void set_state(const char* value, size_t size);
  inline ::std::string* mutable_state();
  inline ::std::string* release_state();


 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* state_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void protobuf_AddDesc_engine_2eproto();
  friend void protobuf_AssignDesc_engine_2eproto();
  friend void protobuf_ShutdownFile_engine_2eproto();

  void InitAsDefaultInstance();
  static Engine_Option* default_instance_;
};


class Engine : public ::google::protobuf::Message {
 public:
  Engine();
  virtual ~Engine();

  Engine(const Engine& from);

  inline Engine& operator=(const Engine& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Engine& default_instance();

  void Swap(Engine* other);



  Engine* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Engine& from);
  void MergeFrom(const Engine& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;



  typedef Engine_Option Option;




  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline int options_size() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 2;
  inline const ::drizzled::message::Engine_Option& options(int index) const;
  inline ::drizzled::message::Engine_Option* mutable_options(int index);
  inline ::drizzled::message::Engine_Option* add_options();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Engine_Option >&
      options() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Engine_Option >*
      mutable_options();


 private:
  inline void set_has_name();
  inline void clear_has_name();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Engine_Option > options_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void protobuf_AddDesc_engine_2eproto();
  friend void protobuf_AssignDesc_engine_2eproto();
  friend void protobuf_ShutdownFile_engine_2eproto();

  void InitAsDefaultInstance();
  static Engine* default_instance_;
};
# 248 "./drizzled/message/engine.pb.h"
inline bool Engine_Option::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Engine_Option::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Engine_Option::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Engine_Option::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Engine_Option::name() const {
  return *name_;
}
inline void Engine_Option::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Engine_Option::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Engine_Option::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Engine_Option::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Engine_Option::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Engine_Option::has_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Engine_Option::set_has_state() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Engine_Option::clear_has_state() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Engine_Option::clear_state() {
  if (state_ != &::google::protobuf::internal::kEmptyString) {
    state_->clear();
  }
  clear_has_state();
}
inline const ::std::string& Engine_Option::state() const {
  return *state_;
}
inline void Engine_Option::set_state(const ::std::string& value) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(value);
}
inline void Engine_Option::set_state(const char* value) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(value);
}
inline void Engine_Option::set_state(const char* value, size_t size) {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  state_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Engine_Option::mutable_state() {
  set_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    state_ = new ::std::string;
  }
  return state_;
}
inline ::std::string* Engine_Option::release_state() {
  clear_has_state();
  if (state_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = state_;
    state_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}






inline bool Engine::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Engine::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Engine::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Engine::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Engine::name() const {
  return *name_;
}
inline void Engine::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Engine::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Engine::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Engine::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Engine::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline int Engine::options_size() const {
  return options_.size();
}
inline void Engine::clear_options() {
  options_.Clear();
}
inline const ::drizzled::message::Engine_Option& Engine::options(int index) const {
  return options_.Get(index);
}
inline ::drizzled::message::Engine_Option* Engine::mutable_options(int index) {
  return options_.Mutable(index);
}
inline ::drizzled::message::Engine_Option* Engine::add_options() {
  return options_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Engine_Option >&
Engine::options() const {
  return options_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Engine_Option >*
Engine::mutable_options() {
  return &options_;
}




}
}


namespace google {
namespace protobuf {


}
}
# 27 "./drizzled/message/table.pb.h" 2
# 1 "./drizzled/message/access.pb.h" 1
# 28 "./drizzled/message/access.pb.h"
namespace drizzled {
namespace message {


void protobuf_AddDesc_access_2eproto();
void protobuf_AssignDesc_access_2eproto();
void protobuf_ShutdownFile_access_2eproto();

class Access;



class Access : public ::google::protobuf::Message {
 public:
  Access();
  virtual ~Access();

  Access(const Access& from);

  inline Access& operator=(const Access& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Access& default_instance();

  void Swap(Access* other);



  Access* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Access& from);
  void MergeFrom(const Access& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_definer() const;
  inline void clear_definer();
  static const int kDefinerFieldNumber = 1;
  inline const ::std::string& definer() const;
  inline void set_definer(const ::std::string& value);
  inline void set_definer(const char* value);
  inline void set_definer(const char* value, size_t size);
  inline ::std::string* mutable_definer();
  inline ::std::string* release_definer();


  inline bool has_invoker() const;
  inline void clear_invoker();
  static const int kInvokerFieldNumber = 2;
  inline const ::std::string& invoker() const;
  inline void set_invoker(const ::std::string& value);
  inline void set_invoker(const char* value);
  inline void set_invoker(const char* value, size_t size);
  inline ::std::string* mutable_invoker();
  inline ::std::string* release_invoker();


 private:
  inline void set_has_definer();
  inline void clear_has_definer();
  inline void set_has_invoker();
  inline void clear_has_invoker();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* definer_;
  ::std::string* invoker_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];

  friend void protobuf_AddDesc_access_2eproto();
  friend void protobuf_AssignDesc_access_2eproto();
  friend void protobuf_ShutdownFile_access_2eproto();

  void InitAsDefaultInstance();
  static Access* default_instance_;
};
# 146 "./drizzled/message/access.pb.h"
inline bool Access::has_definer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Access::set_has_definer() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Access::clear_has_definer() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Access::clear_definer() {
  if (definer_ != &::google::protobuf::internal::kEmptyString) {
    definer_->clear();
  }
  clear_has_definer();
}
inline const ::std::string& Access::definer() const {
  return *definer_;
}
inline void Access::set_definer(const ::std::string& value) {
  set_has_definer();
  if (definer_ == &::google::protobuf::internal::kEmptyString) {
    definer_ = new ::std::string;
  }
  definer_->assign(value);
}
inline void Access::set_definer(const char* value) {
  set_has_definer();
  if (definer_ == &::google::protobuf::internal::kEmptyString) {
    definer_ = new ::std::string;
  }
  definer_->assign(value);
}
inline void Access::set_definer(const char* value, size_t size) {
  set_has_definer();
  if (definer_ == &::google::protobuf::internal::kEmptyString) {
    definer_ = new ::std::string;
  }
  definer_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Access::mutable_definer() {
  set_has_definer();
  if (definer_ == &::google::protobuf::internal::kEmptyString) {
    definer_ = new ::std::string;
  }
  return definer_;
}
inline ::std::string* Access::release_definer() {
  clear_has_definer();
  if (definer_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = definer_;
    definer_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Access::has_invoker() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Access::set_has_invoker() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Access::clear_has_invoker() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Access::clear_invoker() {
  if (invoker_ != &::google::protobuf::internal::kEmptyString) {
    invoker_->clear();
  }
  clear_has_invoker();
}
inline const ::std::string& Access::invoker() const {
  return *invoker_;
}
inline void Access::set_invoker(const ::std::string& value) {
  set_has_invoker();
  if (invoker_ == &::google::protobuf::internal::kEmptyString) {
    invoker_ = new ::std::string;
  }
  invoker_->assign(value);
}
inline void Access::set_invoker(const char* value) {
  set_has_invoker();
  if (invoker_ == &::google::protobuf::internal::kEmptyString) {
    invoker_ = new ::std::string;
  }
  invoker_->assign(value);
}
inline void Access::set_invoker(const char* value, size_t size) {
  set_has_invoker();
  if (invoker_ == &::google::protobuf::internal::kEmptyString) {
    invoker_ = new ::std::string;
  }
  invoker_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Access::mutable_invoker() {
  set_has_invoker();
  if (invoker_ == &::google::protobuf::internal::kEmptyString) {
    invoker_ = new ::std::string;
  }
  return invoker_;
}
inline ::std::string* Access::release_invoker() {
  clear_has_invoker();
  if (invoker_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = invoker_;
    invoker_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}




}
}


namespace google {
namespace protobuf {


}
}
# 28 "./drizzled/message/table.pb.h" 2
# 1 "./drizzled/message/replication_options.pb.h" 1
# 28 "./drizzled/message/replication_options.pb.h"
namespace drizzled {
namespace message {


void protobuf_AddDesc_replication_5foptions_2eproto();
void protobuf_AssignDesc_replication_5foptions_2eproto();
void protobuf_ShutdownFile_replication_5foptions_2eproto();

class ReplicationOptions;



class ReplicationOptions : public ::google::protobuf::Message {
 public:
  ReplicationOptions();
  virtual ~ReplicationOptions();

  ReplicationOptions(const ReplicationOptions& from);

  inline ReplicationOptions& operator=(const ReplicationOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const ReplicationOptions& default_instance();

  void Swap(ReplicationOptions* other);



  ReplicationOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const ReplicationOptions& from);
  void MergeFrom(const ReplicationOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_is_replicated() const;
  inline void clear_is_replicated();
  static const int kIsReplicatedFieldNumber = 2;
  inline bool is_replicated() const;
  inline void set_is_replicated(bool value);


 private:
  inline void set_has_is_replicated();
  inline void clear_has_is_replicated();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool is_replicated_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void protobuf_AddDesc_replication_5foptions_2eproto();
  friend void protobuf_AssignDesc_replication_5foptions_2eproto();
  friend void protobuf_ShutdownFile_replication_5foptions_2eproto();

  void InitAsDefaultInstance();
  static ReplicationOptions* default_instance_;
};
# 128 "./drizzled/message/replication_options.pb.h"
inline bool ReplicationOptions::has_is_replicated() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplicationOptions::set_has_is_replicated() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplicationOptions::clear_has_is_replicated() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplicationOptions::clear_is_replicated() {
  is_replicated_ = false;
  clear_has_is_replicated();
}
inline bool ReplicationOptions::is_replicated() const {
  return is_replicated_;
}
inline void ReplicationOptions::set_is_replicated(bool value) {
  set_has_is_replicated();
  is_replicated_ = value;
}




}
}


namespace google {
namespace protobuf {


}
}
# 29 "./drizzled/message/table.pb.h" 2


namespace drizzled {
namespace message {


void protobuf_AddDesc_table_2eproto();
void protobuf_AssignDesc_table_2eproto();
void protobuf_ShutdownFile_table_2eproto();

class Table;
class Table_TableOptions;
class Table_ForeignKeyConstraint;
class Table_Field;
class Table_Field_FieldOptions;
class Table_Field_FieldConstraints;
class Table_Field_NumericFieldOptions;
class Table_Field_StringFieldOptions;
class Table_Field_EnumerationValues;
class Table_Field_TimeFieldOptions;
class Table_Index;
class Table_Index_IndexPart;
class Table_Index_Options;
class AddedFields;

enum Table_ForeignKeyConstraint_ForeignKeyMatchOption {
  Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED = 0,
  Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_FULL = 1,
  Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_PARTIAL = 2,
  Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE = 3
};
bool Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(int value);
const Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MIN = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED;
const Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE;
const int Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_ARRAYSIZE = Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
inline const ::std::string& Table_ForeignKeyConstraint_ForeignKeyMatchOption_Name(Table_ForeignKeyConstraint_ForeignKeyMatchOption value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor(), value);
}
inline bool Table_ForeignKeyConstraint_ForeignKeyMatchOption_Parse(
    const ::std::string& name, Table_ForeignKeyConstraint_ForeignKeyMatchOption* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_ForeignKeyConstraint_ForeignKeyMatchOption>(
    Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor(), name, value);
}
enum Table_ForeignKeyConstraint_ForeignKeyOption {
  Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF = 0,
  Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_RESTRICT = 1,
  Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_CASCADE = 2,
  Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_NULL = 3,
  Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_NO_ACTION = 4,
  Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT = 5
};
bool Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(int value);
const Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MIN = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF;
const Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT;
const int Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_ARRAYSIZE = Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
inline const ::std::string& Table_ForeignKeyConstraint_ForeignKeyOption_Name(Table_ForeignKeyConstraint_ForeignKeyOption value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_ForeignKeyConstraint_ForeignKeyOption_descriptor(), value);
}
inline bool Table_ForeignKeyConstraint_ForeignKeyOption_Parse(
    const ::std::string& name, Table_ForeignKeyConstraint_ForeignKeyOption* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_ForeignKeyConstraint_ForeignKeyOption>(
    Table_ForeignKeyConstraint_ForeignKeyOption_descriptor(), name, value);
}
enum Table_Field_FieldType {
  Table_Field_FieldType_DOUBLE = 0,
  Table_Field_FieldType_VARCHAR = 1,
  Table_Field_FieldType_BLOB = 2,
  Table_Field_FieldType_ENUM = 3,
  Table_Field_FieldType_INTEGER = 4,
  Table_Field_FieldType_BIGINT = 5,
  Table_Field_FieldType_DECIMAL = 6,
  Table_Field_FieldType_DATE = 7,
  Table_Field_FieldType_EPOCH = 9,
  Table_Field_FieldType_DATETIME = 10,
  Table_Field_FieldType_UUID = 11,
  Table_Field_FieldType_TIME = 12,
  Table_Field_FieldType_BOOLEAN = 13,
  Table_Field_FieldType_IPV6 = 14
};
bool Table_Field_FieldType_IsValid(int value);
const Table_Field_FieldType Table_Field_FieldType_FieldType_MIN = Table_Field_FieldType_DOUBLE;
const Table_Field_FieldType Table_Field_FieldType_FieldType_MAX = Table_Field_FieldType_IPV6;
const int Table_Field_FieldType_FieldType_ARRAYSIZE = Table_Field_FieldType_FieldType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_Field_FieldType_descriptor();
inline const ::std::string& Table_Field_FieldType_Name(Table_Field_FieldType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_Field_FieldType_descriptor(), value);
}
inline bool Table_Field_FieldType_Parse(
    const ::std::string& name, Table_Field_FieldType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_Field_FieldType>(
    Table_Field_FieldType_descriptor(), name, value);
}
enum Table_Index_IndexType {
  Table_Index_IndexType_UNKNOWN_INDEX = 0,
  Table_Index_IndexType_BTREE = 1,
  Table_Index_IndexType_RTREE = 2,
  Table_Index_IndexType_HASH = 3,
  Table_Index_IndexType_FULLTEXT = 4
};
bool Table_Index_IndexType_IsValid(int value);
const Table_Index_IndexType Table_Index_IndexType_IndexType_MIN = Table_Index_IndexType_UNKNOWN_INDEX;
const Table_Index_IndexType Table_Index_IndexType_IndexType_MAX = Table_Index_IndexType_FULLTEXT;
const int Table_Index_IndexType_IndexType_ARRAYSIZE = Table_Index_IndexType_IndexType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_Index_IndexType_descriptor();
inline const ::std::string& Table_Index_IndexType_Name(Table_Index_IndexType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_Index_IndexType_descriptor(), value);
}
inline bool Table_Index_IndexType_Parse(
    const ::std::string& name, Table_Index_IndexType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_Index_IndexType>(
    Table_Index_IndexType_descriptor(), name, value);
}
enum Table_TableType {
  Table_TableType_STANDARD = 0,
  Table_TableType_TEMPORARY = 1,
  Table_TableType_INTERNAL = 2,
  Table_TableType_FUNCTION = 3
};
bool Table_TableType_IsValid(int value);
const Table_TableType Table_TableType_TableType_MIN = Table_TableType_STANDARD;
const Table_TableType Table_TableType_TableType_MAX = Table_TableType_FUNCTION;
const int Table_TableType_TableType_ARRAYSIZE = Table_TableType_TableType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_TableType_descriptor();
inline const ::std::string& Table_TableType_Name(Table_TableType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_TableType_descriptor(), value);
}
inline bool Table_TableType_Parse(
    const ::std::string& name, Table_TableType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_TableType>(
    Table_TableType_descriptor(), name, value);
}


class Table_TableOptions : public ::google::protobuf::Message {
 public:
  Table_TableOptions();
  virtual ~Table_TableOptions();

  Table_TableOptions(const Table_TableOptions& from);

  inline Table_TableOptions& operator=(const Table_TableOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_TableOptions& default_instance();

  void Swap(Table_TableOptions* other);



  Table_TableOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_TableOptions& from);
  void MergeFrom(const Table_TableOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_has_user_set_auto_increment_value() const;
  inline void clear_has_user_set_auto_increment_value();
  static const int kHasUserSetAutoIncrementValueFieldNumber = 1;
  inline bool has_user_set_auto_increment_value() const;
  inline void set_has_user_set_auto_increment_value(bool value);


  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 2;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  inline ::std::string* release_collation();


  inline bool has_collation_id() const;
  inline void clear_collation_id();
  static const int kCollationIdFieldNumber = 3;
  inline ::google::protobuf::uint32 collation_id() const;
  inline void set_collation_id(::google::protobuf::uint32 value);


  inline bool has_data_file_name() const;
  inline void clear_data_file_name();
  static const int kDataFileNameFieldNumber = 5;
  inline const ::std::string& data_file_name() const;
  inline void set_data_file_name(const ::std::string& value);
  inline void set_data_file_name(const char* value);
  inline void set_data_file_name(const char* value, size_t size);
  inline ::std::string* mutable_data_file_name();
  inline ::std::string* release_data_file_name();


  inline bool has_index_file_name() const;
  inline void clear_index_file_name();
  static const int kIndexFileNameFieldNumber = 6;
  inline const ::std::string& index_file_name() const;
  inline void set_index_file_name(const ::std::string& value);
  inline void set_index_file_name(const char* value);
  inline void set_index_file_name(const char* value, size_t size);
  inline ::std::string* mutable_index_file_name();
  inline ::std::string* release_index_file_name();


  inline bool has_max_rows() const;
  inline void clear_max_rows();
  static const int kMaxRowsFieldNumber = 7;
  inline ::google::protobuf::uint64 max_rows() const;
  inline void set_max_rows(::google::protobuf::uint64 value);


  inline bool has_min_rows() const;
  inline void clear_min_rows();
  static const int kMinRowsFieldNumber = 8;
  inline ::google::protobuf::uint64 min_rows() const;
  inline void set_min_rows(::google::protobuf::uint64 value);


  inline bool has_auto_increment_value() const;
  inline void clear_auto_increment_value();
  static const int kAutoIncrementValueFieldNumber = 9;
  inline ::google::protobuf::uint64 auto_increment_value() const;
  inline void set_auto_increment_value(::google::protobuf::uint64 value);


  inline bool has_avg_row_length() const;
  inline void clear_avg_row_length();
  static const int kAvgRowLengthFieldNumber = 11;
  inline ::google::protobuf::uint32 avg_row_length() const;
  inline void set_avg_row_length(::google::protobuf::uint32 value);


  inline bool has_block_size() const;
  inline void clear_block_size();
  static const int kBlockSizeFieldNumber = 13;
  inline ::google::protobuf::uint32 block_size() const;
  inline void set_block_size(::google::protobuf::uint32 value);


  inline bool has_comment() const;
  inline void clear_comment();
  static const int kCommentFieldNumber = 14;
  inline const ::std::string& comment() const;
  inline void set_comment(const ::std::string& value);
  inline void set_comment(const char* value);
  inline void set_comment(const char* value, size_t size);
  inline ::std::string* mutable_comment();
  inline ::std::string* release_comment();


  inline bool has_pack_record() const;
  inline void clear_pack_record();
  static const int kPackRecordFieldNumber = 16;
  inline bool pack_record() const;
  inline void set_pack_record(bool value);


  inline bool has_checksum() const;
  inline void clear_checksum();
  static const int kChecksumFieldNumber = 17;
  inline bool checksum() const;
  inline void set_checksum(bool value);


  inline bool has_page_checksum() const;
  inline void clear_page_checksum();
  static const int kPageChecksumFieldNumber = 18;
  inline bool page_checksum() const;
  inline void set_page_checksum(bool value);


  inline bool has_delay_key_write() const;
  inline void clear_delay_key_write();
  static const int kDelayKeyWriteFieldNumber = 19;
  inline bool delay_key_write() const;
  inline void set_delay_key_write(bool value);


  inline bool has_unused() const;
  inline void clear_unused();
  static const int kUnusedFieldNumber = 20;
  inline bool unused() const;
  inline void set_unused(bool value);


 private:
  inline void set_has_has_user_set_auto_increment_value();
  inline void clear_has_has_user_set_auto_increment_value();
  inline void set_has_collation();
  inline void clear_has_collation();
  inline void set_has_collation_id();
  inline void clear_has_collation_id();
  inline void set_has_data_file_name();
  inline void clear_has_data_file_name();
  inline void set_has_index_file_name();
  inline void clear_has_index_file_name();
  inline void set_has_max_rows();
  inline void clear_has_max_rows();
  inline void set_has_min_rows();
  inline void clear_has_min_rows();
  inline void set_has_auto_increment_value();
  inline void clear_has_auto_increment_value();
  inline void set_has_avg_row_length();
  inline void clear_has_avg_row_length();
  inline void set_has_block_size();
  inline void clear_has_block_size();
  inline void set_has_comment();
  inline void clear_has_comment();
  inline void set_has_pack_record();
  inline void clear_has_pack_record();
  inline void set_has_checksum();
  inline void clear_has_checksum();
  inline void set_has_page_checksum();
  inline void clear_has_page_checksum();
  inline void set_has_delay_key_write();
  inline void clear_has_delay_key_write();
  inline void set_has_unused();
  inline void clear_has_unused();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* collation_;
  ::std::string* data_file_name_;
  ::std::string* index_file_name_;
  ::google::protobuf::uint64 max_rows_;
  ::google::protobuf::uint32 collation_id_;
  ::google::protobuf::uint32 avg_row_length_;
  ::google::protobuf::uint64 min_rows_;
  ::google::protobuf::uint64 auto_increment_value_;
  ::google::protobuf::uint32 block_size_;
  bool has_user_set_auto_increment_value_;
  bool pack_record_;
  bool checksum_;
  bool page_checksum_;
  ::std::string* comment_;
  bool delay_key_write_;
  bool unused_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(16 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_TableOptions* default_instance_;
};


class Table_ForeignKeyConstraint : public ::google::protobuf::Message {
 public:
  Table_ForeignKeyConstraint();
  virtual ~Table_ForeignKeyConstraint();

  Table_ForeignKeyConstraint(const Table_ForeignKeyConstraint& from);

  inline Table_ForeignKeyConstraint& operator=(const Table_ForeignKeyConstraint& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_ForeignKeyConstraint& default_instance();

  void Swap(Table_ForeignKeyConstraint* other);



  Table_ForeignKeyConstraint* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_ForeignKeyConstraint& from);
  void MergeFrom(const Table_ForeignKeyConstraint& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;



  typedef Table_ForeignKeyConstraint_ForeignKeyMatchOption ForeignKeyMatchOption;
  static const ForeignKeyMatchOption MATCH_UNDEFINED = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED;
  static const ForeignKeyMatchOption MATCH_FULL = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_FULL;
  static const ForeignKeyMatchOption MATCH_PARTIAL = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_PARTIAL;
  static const ForeignKeyMatchOption MATCH_SIMPLE = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE;
  static inline bool ForeignKeyMatchOption_IsValid(int value) {
    return Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value);
  }
  static const ForeignKeyMatchOption ForeignKeyMatchOption_MIN =
    Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MIN;
  static const ForeignKeyMatchOption ForeignKeyMatchOption_MAX =
    Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX;
  static const int ForeignKeyMatchOption_ARRAYSIZE =
    Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  ForeignKeyMatchOption_descriptor() {
    return Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
  }
  static inline const ::std::string& ForeignKeyMatchOption_Name(ForeignKeyMatchOption value) {
    return Table_ForeignKeyConstraint_ForeignKeyMatchOption_Name(value);
  }
  static inline bool ForeignKeyMatchOption_Parse(const ::std::string& name,
      ForeignKeyMatchOption* value) {
    return Table_ForeignKeyConstraint_ForeignKeyMatchOption_Parse(name, value);
  }

  typedef Table_ForeignKeyConstraint_ForeignKeyOption ForeignKeyOption;
  static const ForeignKeyOption OPTION_UNDEF = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF;
  static const ForeignKeyOption OPTION_RESTRICT = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_RESTRICT;
  static const ForeignKeyOption OPTION_CASCADE = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_CASCADE;
  static const ForeignKeyOption OPTION_SET_NULL = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_NULL;
  static const ForeignKeyOption OPTION_NO_ACTION = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_NO_ACTION;
  static const ForeignKeyOption OPTION_SET_DEFAULT = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT;
  static inline bool ForeignKeyOption_IsValid(int value) {
    return Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value);
  }
  static const ForeignKeyOption ForeignKeyOption_MIN =
    Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MIN;
  static const ForeignKeyOption ForeignKeyOption_MAX =
    Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX;
  static const int ForeignKeyOption_ARRAYSIZE =
    Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  ForeignKeyOption_descriptor() {
    return Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
  }
  static inline const ::std::string& ForeignKeyOption_Name(ForeignKeyOption value) {
    return Table_ForeignKeyConstraint_ForeignKeyOption_Name(value);
  }
  static inline bool ForeignKeyOption_Parse(const ::std::string& name,
      ForeignKeyOption* value) {
    return Table_ForeignKeyConstraint_ForeignKeyOption_Parse(name, value);
  }




  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline int column_names_size() const;
  inline void clear_column_names();
  static const int kColumnNamesFieldNumber = 2;
  inline const ::std::string& column_names(int index) const;
  inline ::std::string* mutable_column_names(int index);
  inline void set_column_names(int index, const ::std::string& value);
  inline void set_column_names(int index, const char* value);
  inline void set_column_names(int index, const char* value, size_t size);
  inline ::std::string* add_column_names();
  inline void add_column_names(const ::std::string& value);
  inline void add_column_names(const char* value);
  inline void add_column_names(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& column_names() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_column_names();


  inline bool has_references_table_name() const;
  inline void clear_references_table_name();
  static const int kReferencesTableNameFieldNumber = 3;
  inline const ::std::string& references_table_name() const;
  inline void set_references_table_name(const ::std::string& value);
  inline void set_references_table_name(const char* value);
  inline void set_references_table_name(const char* value, size_t size);
  inline ::std::string* mutable_references_table_name();
  inline ::std::string* release_references_table_name();


  inline int references_columns_size() const;
  inline void clear_references_columns();
  static const int kReferencesColumnsFieldNumber = 4;
  inline const ::std::string& references_columns(int index) const;
  inline ::std::string* mutable_references_columns(int index);
  inline void set_references_columns(int index, const ::std::string& value);
  inline void set_references_columns(int index, const char* value);
  inline void set_references_columns(int index, const char* value, size_t size);
  inline ::std::string* add_references_columns();
  inline void add_references_columns(const ::std::string& value);
  inline void add_references_columns(const char* value);
  inline void add_references_columns(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& references_columns() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_references_columns();


  inline bool has_match() const;
  inline void clear_match();
  static const int kMatchFieldNumber = 5;
  inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption match() const;
  inline void set_match(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption value);


  inline bool has_update_option() const;
  inline void clear_update_option();
  static const int kUpdateOptionFieldNumber = 6;
  inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption update_option() const;
  inline void set_update_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value);


  inline bool has_delete_option() const;
  inline void clear_delete_option();
  static const int kDeleteOptionFieldNumber = 7;
  inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption delete_option() const;
  inline void set_delete_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value);


 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_references_table_name();
  inline void clear_has_references_table_name();
  inline void set_has_match();
  inline void clear_has_match();
  inline void set_has_update_option();
  inline void clear_has_update_option();
  inline void set_has_delete_option();
  inline void clear_has_delete_option();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::google::protobuf::RepeatedPtrField< ::std::string> column_names_;
  ::std::string* references_table_name_;
  ::google::protobuf::RepeatedPtrField< ::std::string> references_columns_;
  int match_;
  int update_option_;
  int delete_option_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_ForeignKeyConstraint* default_instance_;
};


class Table_Field_FieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_FieldOptions();
  virtual ~Table_Field_FieldOptions();

  Table_Field_FieldOptions(const Table_Field_FieldOptions& from);

  inline Table_Field_FieldOptions& operator=(const Table_Field_FieldOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_FieldOptions& default_instance();

  void Swap(Table_Field_FieldOptions* other);



  Table_Field_FieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_FieldOptions& from);
  void MergeFrom(const Table_Field_FieldOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_default_value() const;
  inline void clear_default_value();
  static const int kDefaultValueFieldNumber = 1;
  inline const ::std::string& default_value() const;
  inline void set_default_value(const ::std::string& value);
  inline void set_default_value(const char* value);
  inline void set_default_value(const char* value, size_t size);
  inline ::std::string* mutable_default_value();
  inline ::std::string* release_default_value();


  inline bool has_update_value() const;
  inline void clear_update_value();
  static const int kUpdateValueFieldNumber = 2;
  inline const ::std::string& update_value() const;
  inline void set_update_value(const ::std::string& value);
  inline void set_update_value(const char* value);
  inline void set_update_value(const char* value, size_t size);
  inline ::std::string* mutable_update_value();
  inline ::std::string* release_update_value();


  inline bool has_default_null() const;
  inline void clear_default_null();
  static const int kDefaultNullFieldNumber = 3;
  inline bool default_null() const;
  inline void set_default_null(bool value);


  inline bool has_default_bin_value() const;
  inline void clear_default_bin_value();
  static const int kDefaultBinValueFieldNumber = 4;
  inline const ::std::string& default_bin_value() const;
  inline void set_default_bin_value(const ::std::string& value);
  inline void set_default_bin_value(const char* value);
  inline void set_default_bin_value(const void* value, size_t size);
  inline ::std::string* mutable_default_bin_value();
  inline ::std::string* release_default_bin_value();


  inline bool has_default_expression() const;
  inline void clear_default_expression();
  static const int kDefaultExpressionFieldNumber = 5;
  inline const ::std::string& default_expression() const;
  inline void set_default_expression(const ::std::string& value);
  inline void set_default_expression(const char* value);
  inline void set_default_expression(const char* value, size_t size);
  inline ::std::string* mutable_default_expression();
  inline ::std::string* release_default_expression();


  inline bool has_update_expression() const;
  inline void clear_update_expression();
  static const int kUpdateExpressionFieldNumber = 6;
  inline const ::std::string& update_expression() const;
  inline void set_update_expression(const ::std::string& value);
  inline void set_update_expression(const char* value);
  inline void set_update_expression(const char* value, size_t size);
  inline ::std::string* mutable_update_expression();
  inline ::std::string* release_update_expression();


 private:
  inline void set_has_default_value();
  inline void clear_has_default_value();
  inline void set_has_update_value();
  inline void clear_has_update_value();
  inline void set_has_default_null();
  inline void clear_has_default_null();
  inline void set_has_default_bin_value();
  inline void clear_has_default_bin_value();
  inline void set_has_default_expression();
  inline void clear_has_default_expression();
  inline void set_has_update_expression();
  inline void clear_has_update_expression();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* default_value_;
  ::std::string* update_value_;
  ::std::string* default_bin_value_;
  ::std::string* default_expression_;
  ::std::string* update_expression_;
  bool default_null_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field_FieldOptions* default_instance_;
};


class Table_Field_FieldConstraints : public ::google::protobuf::Message {
 public:
  Table_Field_FieldConstraints();
  virtual ~Table_Field_FieldConstraints();

  Table_Field_FieldConstraints(const Table_Field_FieldConstraints& from);

  inline Table_Field_FieldConstraints& operator=(const Table_Field_FieldConstraints& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_FieldConstraints& default_instance();

  void Swap(Table_Field_FieldConstraints* other);



  Table_Field_FieldConstraints* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_FieldConstraints& from);
  void MergeFrom(const Table_Field_FieldConstraints& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_is_nullable() const;
  inline void clear_is_nullable();
  static const int kIsNullableFieldNumber = 1;
  inline bool is_nullable() const;
  inline void set_is_nullable(bool value);


  inline bool has_is_unsigned() const;
  inline void clear_is_unsigned();
  static const int kIsUnsignedFieldNumber = 2;
  inline bool is_unsigned() const;
  inline void set_is_unsigned(bool value);


  inline bool has_is_notnull() const;
  inline void clear_is_notnull();
  static const int kIsNotnullFieldNumber = 3;
  inline bool is_notnull() const;
  inline void set_is_notnull(bool value);


  inline bool has_is_unique() const;
  inline void clear_is_unique();
  static const int kIsUniqueFieldNumber = 4;
  inline bool is_unique() const;
  inline void set_is_unique(bool value);


  inline int expression_size() const;
  inline void clear_expression();
  static const int kExpressionFieldNumber = 16;
  inline const ::std::string& expression(int index) const;
  inline ::std::string* mutable_expression(int index);
  inline void set_expression(int index, const ::std::string& value);
  inline void set_expression(int index, const char* value);
  inline void set_expression(int index, const char* value, size_t size);
  inline ::std::string* add_expression();
  inline void add_expression(const ::std::string& value);
  inline void add_expression(const char* value);
  inline void add_expression(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& expression() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_expression();


 private:
  inline void set_has_is_nullable();
  inline void clear_has_is_nullable();
  inline void set_has_is_unsigned();
  inline void clear_has_is_unsigned();
  inline void set_has_is_notnull();
  inline void clear_has_is_notnull();
  inline void set_has_is_unique();
  inline void clear_has_is_unique();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::std::string> expression_;
  bool is_nullable_;
  bool is_unsigned_;
  bool is_notnull_;
  bool is_unique_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field_FieldConstraints* default_instance_;
};


class Table_Field_NumericFieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_NumericFieldOptions();
  virtual ~Table_Field_NumericFieldOptions();

  Table_Field_NumericFieldOptions(const Table_Field_NumericFieldOptions& from);

  inline Table_Field_NumericFieldOptions& operator=(const Table_Field_NumericFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_NumericFieldOptions& default_instance();

  void Swap(Table_Field_NumericFieldOptions* other);



  Table_Field_NumericFieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_NumericFieldOptions& from);
  void MergeFrom(const Table_Field_NumericFieldOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_is_autoincrement() const;
  inline void clear_is_autoincrement();
  static const int kIsAutoincrementFieldNumber = 1;
  inline bool is_autoincrement() const;
  inline void set_is_autoincrement(bool value);


  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline ::google::protobuf::uint32 scale() const;
  inline void set_scale(::google::protobuf::uint32 value);


  inline bool has_precision() const;
  inline void clear_precision();
  static const int kPrecisionFieldNumber = 3;
  inline ::google::protobuf::uint32 precision() const;
  inline void set_precision(::google::protobuf::uint32 value);


 private:
  inline void set_has_is_autoincrement();
  inline void clear_has_is_autoincrement();
  inline void set_has_scale();
  inline void clear_has_scale();
  inline void set_has_precision();
  inline void clear_has_precision();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool is_autoincrement_;
  ::google::protobuf::uint32 scale_;
  ::google::protobuf::uint32 precision_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field_NumericFieldOptions* default_instance_;
};


class Table_Field_StringFieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_StringFieldOptions();
  virtual ~Table_Field_StringFieldOptions();

  Table_Field_StringFieldOptions(const Table_Field_StringFieldOptions& from);

  inline Table_Field_StringFieldOptions& operator=(const Table_Field_StringFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_StringFieldOptions& default_instance();

  void Swap(Table_Field_StringFieldOptions* other);



  Table_Field_StringFieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_StringFieldOptions& from);
  void MergeFrom(const Table_Field_StringFieldOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_is_fixed_width() const;
  inline void clear_is_fixed_width();
  static const int kIsFixedWidthFieldNumber = 1;
  inline bool is_fixed_width() const;
  inline void set_is_fixed_width(bool value);


  inline bool has_length() const;
  inline void clear_length();
  static const int kLengthFieldNumber = 2;
  inline ::google::protobuf::uint32 length() const;
  inline void set_length(::google::protobuf::uint32 value);


  inline bool has_collation_id() const;
  inline void clear_collation_id();
  static const int kCollationIdFieldNumber = 3;
  inline ::google::protobuf::uint32 collation_id() const;
  inline void set_collation_id(::google::protobuf::uint32 value);


  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 4;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  inline ::std::string* release_collation();


 private:
  inline void set_has_is_fixed_width();
  inline void clear_has_is_fixed_width();
  inline void set_has_length();
  inline void clear_has_length();
  inline void set_has_collation_id();
  inline void clear_has_collation_id();
  inline void set_has_collation();
  inline void clear_has_collation();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool is_fixed_width_;
  ::google::protobuf::uint32 length_;
  ::std::string* collation_;
  ::google::protobuf::uint32 collation_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field_StringFieldOptions* default_instance_;
};


class Table_Field_EnumerationValues : public ::google::protobuf::Message {
 public:
  Table_Field_EnumerationValues();
  virtual ~Table_Field_EnumerationValues();

  Table_Field_EnumerationValues(const Table_Field_EnumerationValues& from);

  inline Table_Field_EnumerationValues& operator=(const Table_Field_EnumerationValues& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_EnumerationValues& default_instance();

  void Swap(Table_Field_EnumerationValues* other);



  Table_Field_EnumerationValues* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_EnumerationValues& from);
  void MergeFrom(const Table_Field_EnumerationValues& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_collation_id() const;
  inline void clear_collation_id();
  static const int kCollationIdFieldNumber = 2;
  inline ::google::protobuf::uint32 collation_id() const;
  inline void set_collation_id(::google::protobuf::uint32 value);


  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 3;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  inline ::std::string* release_collation();


  inline int field_value_size() const;
  inline void clear_field_value();
  static const int kFieldValueFieldNumber = 4;
  inline const ::std::string& field_value(int index) const;
  inline ::std::string* mutable_field_value(int index);
  inline void set_field_value(int index, const ::std::string& value);
  inline void set_field_value(int index, const char* value);
  inline void set_field_value(int index, const char* value, size_t size);
  inline ::std::string* add_field_value();
  inline void add_field_value(const ::std::string& value);
  inline void add_field_value(const char* value);
  inline void add_field_value(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& field_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_field_value();


 private:
  inline void set_has_collation_id();
  inline void clear_has_collation_id();
  inline void set_has_collation();
  inline void clear_has_collation();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* collation_;
  ::google::protobuf::RepeatedPtrField< ::std::string> field_value_;
  ::google::protobuf::uint32 collation_id_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field_EnumerationValues* default_instance_;
};


class Table_Field_TimeFieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_TimeFieldOptions();
  virtual ~Table_Field_TimeFieldOptions();

  Table_Field_TimeFieldOptions(const Table_Field_TimeFieldOptions& from);

  inline Table_Field_TimeFieldOptions& operator=(const Table_Field_TimeFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_TimeFieldOptions& default_instance();

  void Swap(Table_Field_TimeFieldOptions* other);



  Table_Field_TimeFieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_TimeFieldOptions& from);
  void MergeFrom(const Table_Field_TimeFieldOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_microseconds() const;
  inline void clear_microseconds();
  static const int kMicrosecondsFieldNumber = 1;
  inline bool microseconds() const;
  inline void set_microseconds(bool value);


 private:
  inline void set_has_microseconds();
  inline void clear_has_microseconds();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool microseconds_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field_TimeFieldOptions* default_instance_;
};


class Table_Field : public ::google::protobuf::Message {
 public:
  Table_Field();
  virtual ~Table_Field();

  Table_Field(const Table_Field& from);

  inline Table_Field& operator=(const Table_Field& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field& default_instance();

  void Swap(Table_Field* other);



  Table_Field* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field& from);
  void MergeFrom(const Table_Field& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;



  typedef Table_Field_FieldOptions FieldOptions;
  typedef Table_Field_FieldConstraints FieldConstraints;
  typedef Table_Field_NumericFieldOptions NumericFieldOptions;
  typedef Table_Field_StringFieldOptions StringFieldOptions;
  typedef Table_Field_EnumerationValues EnumerationValues;
  typedef Table_Field_TimeFieldOptions TimeFieldOptions;

  typedef Table_Field_FieldType FieldType;
  static const FieldType DOUBLE = Table_Field_FieldType_DOUBLE;
  static const FieldType VARCHAR = Table_Field_FieldType_VARCHAR;
  static const FieldType BLOB = Table_Field_FieldType_BLOB;
  static const FieldType ENUM = Table_Field_FieldType_ENUM;
  static const FieldType INTEGER = Table_Field_FieldType_INTEGER;
  static const FieldType BIGINT = Table_Field_FieldType_BIGINT;
  static const FieldType DECIMAL = Table_Field_FieldType_DECIMAL;
  static const FieldType DATE = Table_Field_FieldType_DATE;
  static const FieldType EPOCH = Table_Field_FieldType_EPOCH;
  static const FieldType DATETIME = Table_Field_FieldType_DATETIME;
  static const FieldType UUID = Table_Field_FieldType_UUID;
  static const FieldType TIME = Table_Field_FieldType_TIME;
  static const FieldType BOOLEAN = Table_Field_FieldType_BOOLEAN;
  static const FieldType IPV6 = Table_Field_FieldType_IPV6;
  static inline bool FieldType_IsValid(int value) {
    return Table_Field_FieldType_IsValid(value);
  }
  static const FieldType FieldType_MIN =
    Table_Field_FieldType_FieldType_MIN;
  static const FieldType FieldType_MAX =
    Table_Field_FieldType_FieldType_MAX;
  static const int FieldType_ARRAYSIZE =
    Table_Field_FieldType_FieldType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  FieldType_descriptor() {
    return Table_Field_FieldType_descriptor();
  }
  static inline const ::std::string& FieldType_Name(FieldType value) {
    return Table_Field_FieldType_Name(value);
  }
  static inline bool FieldType_Parse(const ::std::string& name,
      FieldType* value) {
    return Table_Field_FieldType_Parse(name, value);
  }




  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::drizzled::message::Table_Field_FieldType type() const;
  inline void set_type(::drizzled::message::Table_Field_FieldType value);


  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 4;
  inline const ::drizzled::message::Table_Field_FieldOptions& options() const;
  inline ::drizzled::message::Table_Field_FieldOptions* mutable_options();
  inline ::drizzled::message::Table_Field_FieldOptions* release_options();


  inline bool has_constraints() const;
  inline void clear_constraints();
  static const int kConstraintsFieldNumber = 5;
  inline const ::drizzled::message::Table_Field_FieldConstraints& constraints() const;
  inline ::drizzled::message::Table_Field_FieldConstraints* mutable_constraints();
  inline ::drizzled::message::Table_Field_FieldConstraints* release_constraints();


  inline bool has_numeric_options() const;
  inline void clear_numeric_options();
  static const int kNumericOptionsFieldNumber = 6;
  inline const ::drizzled::message::Table_Field_NumericFieldOptions& numeric_options() const;
  inline ::drizzled::message::Table_Field_NumericFieldOptions* mutable_numeric_options();
  inline ::drizzled::message::Table_Field_NumericFieldOptions* release_numeric_options();


  inline bool has_string_options() const;
  inline void clear_string_options();
  static const int kStringOptionsFieldNumber = 7;
  inline const ::drizzled::message::Table_Field_StringFieldOptions& string_options() const;
  inline ::drizzled::message::Table_Field_StringFieldOptions* mutable_string_options();
  inline ::drizzled::message::Table_Field_StringFieldOptions* release_string_options();


  inline bool has_time_options() const;
  inline void clear_time_options();
  static const int kTimeOptionsFieldNumber = 8;
  inline const ::drizzled::message::Table_Field_TimeFieldOptions& time_options() const;
  inline ::drizzled::message::Table_Field_TimeFieldOptions* mutable_time_options();
  inline ::drizzled::message::Table_Field_TimeFieldOptions* release_time_options();


  inline bool has_comment() const;
  inline void clear_comment();
  static const int kCommentFieldNumber = 16;
  inline const ::std::string& comment() const;
  inline void set_comment(const ::std::string& value);
  inline void set_comment(const char* value);
  inline void set_comment(const char* value, size_t size);
  inline ::std::string* mutable_comment();
  inline ::std::string* release_comment();


  inline bool has_enumeration_values() const;
  inline void clear_enumeration_values();
  static const int kEnumerationValuesFieldNumber = 17;
  inline const ::drizzled::message::Table_Field_EnumerationValues& enumeration_values() const;
  inline ::drizzled::message::Table_Field_EnumerationValues* mutable_enumeration_values();
  inline ::drizzled::message::Table_Field_EnumerationValues* release_enumeration_values();


 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_options();
  inline void clear_has_options();
  inline void set_has_constraints();
  inline void clear_has_constraints();
  inline void set_has_numeric_options();
  inline void clear_has_numeric_options();
  inline void set_has_string_options();
  inline void clear_has_string_options();
  inline void set_has_time_options();
  inline void clear_has_time_options();
  inline void set_has_comment();
  inline void clear_has_comment();
  inline void set_has_enumeration_values();
  inline void clear_has_enumeration_values();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::drizzled::message::Table_Field_FieldOptions* options_;
  ::drizzled::message::Table_Field_FieldConstraints* constraints_;
  ::drizzled::message::Table_Field_NumericFieldOptions* numeric_options_;
  ::drizzled::message::Table_Field_StringFieldOptions* string_options_;
  ::drizzled::message::Table_Field_TimeFieldOptions* time_options_;
  ::std::string* comment_;
  ::drizzled::message::Table_Field_EnumerationValues* enumeration_values_;
  int type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Field* default_instance_;
};


class Table_Index_IndexPart : public ::google::protobuf::Message {
 public:
  Table_Index_IndexPart();
  virtual ~Table_Index_IndexPart();

  Table_Index_IndexPart(const Table_Index_IndexPart& from);

  inline Table_Index_IndexPart& operator=(const Table_Index_IndexPart& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Index_IndexPart& default_instance();

  void Swap(Table_Index_IndexPart* other);



  Table_Index_IndexPart* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Index_IndexPart& from);
  void MergeFrom(const Table_Index_IndexPart& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_fieldnr() const;
  inline void clear_fieldnr();
  static const int kFieldnrFieldNumber = 1;
  inline ::google::protobuf::uint32 fieldnr() const;
  inline void set_fieldnr(::google::protobuf::uint32 value);


  inline bool has_compare_length() const;
  inline void clear_compare_length();
  static const int kCompareLengthFieldNumber = 2;
  inline ::google::protobuf::uint32 compare_length() const;
  inline void set_compare_length(::google::protobuf::uint32 value);


  inline bool has_in_reverse_order() const;
  inline void clear_in_reverse_order();
  static const int kInReverseOrderFieldNumber = 3;
  inline bool in_reverse_order() const;
  inline void set_in_reverse_order(bool value);


 private:
  inline void set_has_fieldnr();
  inline void clear_has_fieldnr();
  inline void set_has_compare_length();
  inline void clear_has_compare_length();
  inline void set_has_in_reverse_order();
  inline void clear_has_in_reverse_order();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 fieldnr_;
  ::google::protobuf::uint32 compare_length_;
  bool in_reverse_order_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Index_IndexPart* default_instance_;
};


class Table_Index_Options : public ::google::protobuf::Message {
 public:
  Table_Index_Options();
  virtual ~Table_Index_Options();

  Table_Index_Options(const Table_Index_Options& from);

  inline Table_Index_Options& operator=(const Table_Index_Options& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Index_Options& default_instance();

  void Swap(Table_Index_Options* other);



  Table_Index_Options* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Index_Options& from);
  void MergeFrom(const Table_Index_Options& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline bool has_pack_key() const;
  inline void clear_pack_key();
  static const int kPackKeyFieldNumber = 1;
  inline bool pack_key() const;
  inline void set_pack_key(bool value);


  inline bool has_binary_pack_key() const;
  inline void clear_binary_pack_key();
  static const int kBinaryPackKeyFieldNumber = 2;
  inline bool binary_pack_key() const;
  inline void set_binary_pack_key(bool value);


  inline bool has_var_length_key() const;
  inline void clear_var_length_key();
  static const int kVarLengthKeyFieldNumber = 3;
  inline bool var_length_key() const;
  inline void set_var_length_key(bool value);


  inline bool has_null_part_key() const;
  inline void clear_null_part_key();
  static const int kNullPartKeyFieldNumber = 4;
  inline bool null_part_key() const;
  inline void set_null_part_key(bool value);


  inline bool has_key_block_size() const;
  inline void clear_key_block_size();
  static const int kKeyBlockSizeFieldNumber = 5;
  inline ::google::protobuf::uint32 key_block_size() const;
  inline void set_key_block_size(::google::protobuf::uint32 value);


  inline bool has_has_partial_segments() const;
  inline void clear_has_partial_segments();
  static const int kHasPartialSegmentsFieldNumber = 6;
  inline bool has_partial_segments() const;
  inline void set_has_partial_segments(bool value);


  inline bool has_auto_generated_key() const;
  inline void clear_auto_generated_key();
  static const int kAutoGeneratedKeyFieldNumber = 7;
  inline bool auto_generated_key() const;
  inline void set_auto_generated_key(bool value);


 private:
  inline void set_has_pack_key();
  inline void clear_has_pack_key();
  inline void set_has_binary_pack_key();
  inline void clear_has_binary_pack_key();
  inline void set_has_var_length_key();
  inline void clear_has_var_length_key();
  inline void set_has_null_part_key();
  inline void clear_has_null_part_key();
  inline void set_has_key_block_size();
  inline void clear_has_key_block_size();
  inline void set_has_has_partial_segments();
  inline void clear_has_has_partial_segments();
  inline void set_has_auto_generated_key();
  inline void clear_has_auto_generated_key();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  bool pack_key_;
  bool binary_pack_key_;
  bool var_length_key_;
  bool null_part_key_;
  ::google::protobuf::uint32 key_block_size_;
  bool has_partial_segments_;
  bool auto_generated_key_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Index_Options* default_instance_;
};


class Table_Index : public ::google::protobuf::Message {
 public:
  Table_Index();
  virtual ~Table_Index();

  Table_Index(const Table_Index& from);

  inline Table_Index& operator=(const Table_Index& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Index& default_instance();

  void Swap(Table_Index* other);



  Table_Index* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Index& from);
  void MergeFrom(const Table_Index& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;



  typedef Table_Index_IndexPart IndexPart;
  typedef Table_Index_Options Options;

  typedef Table_Index_IndexType IndexType;
  static const IndexType UNKNOWN_INDEX = Table_Index_IndexType_UNKNOWN_INDEX;
  static const IndexType BTREE = Table_Index_IndexType_BTREE;
  static const IndexType RTREE = Table_Index_IndexType_RTREE;
  static const IndexType HASH = Table_Index_IndexType_HASH;
  static const IndexType FULLTEXT = Table_Index_IndexType_FULLTEXT;
  static inline bool IndexType_IsValid(int value) {
    return Table_Index_IndexType_IsValid(value);
  }
  static const IndexType IndexType_MIN =
    Table_Index_IndexType_IndexType_MIN;
  static const IndexType IndexType_MAX =
    Table_Index_IndexType_IndexType_MAX;
  static const int IndexType_ARRAYSIZE =
    Table_Index_IndexType_IndexType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  IndexType_descriptor() {
    return Table_Index_IndexType_descriptor();
  }
  static inline const ::std::string& IndexType_Name(IndexType value) {
    return Table_Index_IndexType_Name(value);
  }
  static inline bool IndexType_Parse(const ::std::string& name,
      IndexType* value) {
    return Table_Index_IndexType_Parse(name, value);
  }




  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline bool has_is_primary() const;
  inline void clear_is_primary();
  static const int kIsPrimaryFieldNumber = 2;
  inline bool is_primary() const;
  inline void set_is_primary(bool value);


  inline bool has_is_unique() const;
  inline void clear_is_unique();
  static const int kIsUniqueFieldNumber = 3;
  inline bool is_unique() const;
  inline void set_is_unique(bool value);


  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 4;
  inline ::drizzled::message::Table_Index_IndexType type() const;
  inline void set_type(::drizzled::message::Table_Index_IndexType value);


  inline bool has_key_length() const;
  inline void clear_key_length();
  static const int kKeyLengthFieldNumber = 5;
  inline ::google::protobuf::uint32 key_length() const;
  inline void set_key_length(::google::protobuf::uint32 value);


  inline int index_part_size() const;
  inline void clear_index_part();
  static const int kIndexPartFieldNumber = 6;
  inline const ::drizzled::message::Table_Index_IndexPart& index_part(int index) const;
  inline ::drizzled::message::Table_Index_IndexPart* mutable_index_part(int index);
  inline ::drizzled::message::Table_Index_IndexPart* add_index_part();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
      index_part() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
      mutable_index_part();


  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 7;
  inline const ::drizzled::message::Table_Index_Options& options() const;
  inline ::drizzled::message::Table_Index_Options* mutable_options();
  inline ::drizzled::message::Table_Index_Options* release_options();


  inline bool has_comment() const;
  inline void clear_comment();
  static const int kCommentFieldNumber = 8;
  inline const ::std::string& comment() const;
  inline void set_comment(const ::std::string& value);
  inline void set_comment(const char* value);
  inline void set_comment(const char* value, size_t size);
  inline ::std::string* mutable_comment();
  inline ::std::string* release_comment();


 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_is_primary();
  inline void clear_has_is_primary();
  inline void set_has_is_unique();
  inline void clear_has_is_unique();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_key_length();
  inline void clear_has_key_length();
  inline void set_has_options();
  inline void clear_has_options();
  inline void set_has_comment();
  inline void clear_has_comment();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  bool is_primary_;
  bool is_unique_;
  int type_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart > index_part_;
  ::drizzled::message::Table_Index_Options* options_;
  ::std::string* comment_;
  ::google::protobuf::uint32 key_length_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table_Index* default_instance_;
};


class Table : public ::google::protobuf::Message {
 public:
  Table();
  virtual ~Table();

  Table(const Table& from);

  inline Table& operator=(const Table& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Table& default_instance();

  void Swap(Table* other);



  Table* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table& from);
  void MergeFrom(const Table& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;



  typedef Table_TableOptions TableOptions;
  typedef Table_ForeignKeyConstraint ForeignKeyConstraint;
  typedef Table_Field Field;
  typedef Table_Index Index;

  typedef Table_TableType TableType;
  static const TableType STANDARD = Table_TableType_STANDARD;
  static const TableType TEMPORARY = Table_TableType_TEMPORARY;
  static const TableType INTERNAL = Table_TableType_INTERNAL;
  static const TableType FUNCTION = Table_TableType_FUNCTION;
  static inline bool TableType_IsValid(int value) {
    return Table_TableType_IsValid(value);
  }
  static const TableType TableType_MIN =
    Table_TableType_TableType_MIN;
  static const TableType TableType_MAX =
    Table_TableType_TableType_MAX;
  static const int TableType_ARRAYSIZE =
    Table_TableType_TableType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  TableType_descriptor() {
    return Table_TableType_descriptor();
  }
  static inline const ::std::string& TableType_Name(TableType value) {
    return Table_TableType_Name(value);
  }
  static inline bool TableType_Parse(const ::std::string& name,
      TableType* value) {
    return Table_TableType_Parse(name, value);
  }




  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline bool has_schema() const;
  inline void clear_schema();
  static const int kSchemaFieldNumber = 6;
  inline const ::std::string& schema() const;
  inline void set_schema(const ::std::string& value);
  inline void set_schema(const char* value);
  inline void set_schema(const char* value, size_t size);
  inline ::std::string* mutable_schema();
  inline ::std::string* release_schema();


  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 5;
  inline ::drizzled::message::Table_TableType type() const;
  inline void set_type(::drizzled::message::Table_TableType value);


  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 2;
  inline const ::drizzled::message::Engine& engine() const;
  inline ::drizzled::message::Engine* mutable_engine();
  inline ::drizzled::message::Engine* release_engine();


  inline int field_size() const;
  inline void clear_field();
  static const int kFieldFieldNumber = 3;
  inline const ::drizzled::message::Table_Field& field(int index) const;
  inline ::drizzled::message::Table_Field* mutable_field(int index);
  inline ::drizzled::message::Table_Field* add_field();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
      field() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
      mutable_field();


  inline int indexes_size() const;
  inline void clear_indexes();
  static const int kIndexesFieldNumber = 4;
  inline const ::drizzled::message::Table_Index& indexes(int index) const;
  inline ::drizzled::message::Table_Index* mutable_indexes(int index);
  inline ::drizzled::message::Table_Index* add_indexes();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
      indexes() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
      mutable_indexes();


  inline int fk_constraint_size() const;
  inline void clear_fk_constraint();
  static const int kFkConstraintFieldNumber = 8;
  inline const ::drizzled::message::Table_ForeignKeyConstraint& fk_constraint(int index) const;
  inline ::drizzled::message::Table_ForeignKeyConstraint* mutable_fk_constraint(int index);
  inline ::drizzled::message::Table_ForeignKeyConstraint* add_fk_constraint();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
      fk_constraint() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
      mutable_fk_constraint();


  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 9;
  inline const ::drizzled::message::Table_TableOptions& options() const;
  inline ::drizzled::message::Table_TableOptions* mutable_options();
  inline ::drizzled::message::Table_TableOptions* release_options();


  inline bool has_creation_timestamp() const;
  inline void clear_creation_timestamp();
  static const int kCreationTimestampFieldNumber = 11;
  inline ::google::protobuf::uint64 creation_timestamp() const;
  inline void set_creation_timestamp(::google::protobuf::uint64 value);


  inline bool has_update_timestamp() const;
  inline void clear_update_timestamp();
  static const int kUpdateTimestampFieldNumber = 12;
  inline ::google::protobuf::uint64 update_timestamp() const;
  inline void set_update_timestamp(::google::protobuf::uint64 value);


  inline bool has_catalog() const;
  inline void clear_catalog();
  static const int kCatalogFieldNumber = 13;
  inline const ::std::string& catalog() const;
  inline void set_catalog(const ::std::string& value);
  inline void set_catalog(const char* value);
  inline void set_catalog(const char* value, size_t size);
  inline ::std::string* mutable_catalog();
  inline ::std::string* release_catalog();


  inline bool has_uuid() const;
  inline void clear_uuid();
  static const int kUuidFieldNumber = 14;
  inline const ::std::string& uuid() const;
  inline void set_uuid(const ::std::string& value);
  inline void set_uuid(const char* value);
  inline void set_uuid(const char* value, size_t size);
  inline ::std::string* mutable_uuid();
  inline ::std::string* release_uuid();


  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 15;
  inline ::google::protobuf::uint64 version() const;
  inline void set_version(::google::protobuf::uint64 value);


  inline bool has_replication_options() const;
  inline void clear_replication_options();
  static const int kReplicationOptionsFieldNumber = 16;
  inline const ::drizzled::message::ReplicationOptions& replication_options() const;
  inline ::drizzled::message::ReplicationOptions* mutable_replication_options();
  inline ::drizzled::message::ReplicationOptions* release_replication_options();


  inline bool has_access() const;
  inline void clear_access();
  static const int kAccessFieldNumber = 17;
  inline const ::drizzled::message::Access& access() const;
  inline ::drizzled::message::Access* mutable_access();
  inline ::drizzled::message::Access* release_access();


 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_schema();
  inline void clear_has_schema();
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_engine();
  inline void clear_has_engine();
  inline void set_has_options();
  inline void clear_has_options();
  inline void set_has_creation_timestamp();
  inline void clear_has_creation_timestamp();
  inline void set_has_update_timestamp();
  inline void clear_has_update_timestamp();
  inline void set_has_catalog();
  inline void clear_has_catalog();
  inline void set_has_uuid();
  inline void clear_has_uuid();
  inline void set_has_version();
  inline void clear_has_version();
  inline void set_has_replication_options();
  inline void clear_has_replication_options();
  inline void set_has_access();
  inline void clear_has_access();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* schema_;
  ::drizzled::message::Engine* engine_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > field_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index > indexes_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint > fk_constraint_;
  ::drizzled::message::Table_TableOptions* options_;
  ::google::protobuf::uint64 creation_timestamp_;
  ::google::protobuf::uint64 update_timestamp_;
  ::std::string* catalog_;
  ::std::string* uuid_;
  ::google::protobuf::uint64 version_;
  ::drizzled::message::ReplicationOptions* replication_options_;
  ::drizzled::message::Access* access_;
  int type_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(15 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static Table* default_instance_;
};


class AddedFields : public ::google::protobuf::Message {
 public:
  AddedFields();
  virtual ~AddedFields();

  AddedFields(const AddedFields& from);

  inline AddedFields& operator=(const AddedFields& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const AddedFields& default_instance();

  void Swap(AddedFields* other);



  AddedFields* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AddedFields& from);
  void MergeFrom(const AddedFields& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






  inline int added_field_size() const;
  inline void clear_added_field();
  static const int kAddedFieldFieldNumber = 1;
  inline const ::drizzled::message::Table_Field& added_field(int index) const;
  inline ::drizzled::message::Table_Field* mutable_added_field(int index);
  inline ::drizzled::message::Table_Field* add_added_field();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
      added_field() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
      mutable_added_field();


 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > added_field_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];

  friend void protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();

  void InitAsDefaultInstance();
  static AddedFields* default_instance_;
};
# 2364 "./drizzled/message/table.pb.h"
inline bool Table_TableOptions::has_has_user_set_auto_increment_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_TableOptions::set_has_has_user_set_auto_increment_value() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_TableOptions::clear_has_has_user_set_auto_increment_value() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_TableOptions::clear_has_user_set_auto_increment_value() {
  has_user_set_auto_increment_value_ = false;
  clear_has_has_user_set_auto_increment_value();
}
inline bool Table_TableOptions::has_user_set_auto_increment_value() const {
  return has_user_set_auto_increment_value_;
}
inline void Table_TableOptions::set_has_user_set_auto_increment_value(bool value) {
  set_has_has_user_set_auto_increment_value();
  has_user_set_auto_increment_value_ = value;
}


inline bool Table_TableOptions::has_collation() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_TableOptions::set_has_collation() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_TableOptions::clear_has_collation() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_TableOptions::clear_collation() {
  if (collation_ != &::google::protobuf::internal::kEmptyString) {
    collation_->clear();
  }
  clear_has_collation();
}
inline const ::std::string& Table_TableOptions::collation() const {
  return *collation_;
}
inline void Table_TableOptions::set_collation(const ::std::string& value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_TableOptions::set_collation(const char* value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_TableOptions::set_collation(const char* value, size_t size) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_collation() {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  return collation_;
}
inline ::std::string* Table_TableOptions::release_collation() {
  clear_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = collation_;
    collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_TableOptions::has_collation_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_TableOptions::set_has_collation_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_TableOptions::clear_has_collation_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_TableOptions::clear_collation_id() {
  collation_id_ = 0u;
  clear_has_collation_id();
}
inline ::google::protobuf::uint32 Table_TableOptions::collation_id() const {
  return collation_id_;
}
inline void Table_TableOptions::set_collation_id(::google::protobuf::uint32 value) {
  set_has_collation_id();
  collation_id_ = value;
}


inline bool Table_TableOptions::has_data_file_name() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_TableOptions::set_has_data_file_name() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_TableOptions::clear_has_data_file_name() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_TableOptions::clear_data_file_name() {
  if (data_file_name_ != &::google::protobuf::internal::kEmptyString) {
    data_file_name_->clear();
  }
  clear_has_data_file_name();
}
inline const ::std::string& Table_TableOptions::data_file_name() const {
  return *data_file_name_;
}
inline void Table_TableOptions::set_data_file_name(const ::std::string& value) {
  set_has_data_file_name();
  if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
    data_file_name_ = new ::std::string;
  }
  data_file_name_->assign(value);
}
inline void Table_TableOptions::set_data_file_name(const char* value) {
  set_has_data_file_name();
  if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
    data_file_name_ = new ::std::string;
  }
  data_file_name_->assign(value);
}
inline void Table_TableOptions::set_data_file_name(const char* value, size_t size) {
  set_has_data_file_name();
  if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
    data_file_name_ = new ::std::string;
  }
  data_file_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_data_file_name() {
  set_has_data_file_name();
  if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
    data_file_name_ = new ::std::string;
  }
  return data_file_name_;
}
inline ::std::string* Table_TableOptions::release_data_file_name() {
  clear_has_data_file_name();
  if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = data_file_name_;
    data_file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_TableOptions::has_index_file_name() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Table_TableOptions::set_has_index_file_name() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Table_TableOptions::clear_has_index_file_name() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Table_TableOptions::clear_index_file_name() {
  if (index_file_name_ != &::google::protobuf::internal::kEmptyString) {
    index_file_name_->clear();
  }
  clear_has_index_file_name();
}
inline const ::std::string& Table_TableOptions::index_file_name() const {
  return *index_file_name_;
}
inline void Table_TableOptions::set_index_file_name(const ::std::string& value) {
  set_has_index_file_name();
  if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
    index_file_name_ = new ::std::string;
  }
  index_file_name_->assign(value);
}
inline void Table_TableOptions::set_index_file_name(const char* value) {
  set_has_index_file_name();
  if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
    index_file_name_ = new ::std::string;
  }
  index_file_name_->assign(value);
}
inline void Table_TableOptions::set_index_file_name(const char* value, size_t size) {
  set_has_index_file_name();
  if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
    index_file_name_ = new ::std::string;
  }
  index_file_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_index_file_name() {
  set_has_index_file_name();
  if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
    index_file_name_ = new ::std::string;
  }
  return index_file_name_;
}
inline ::std::string* Table_TableOptions::release_index_file_name() {
  clear_has_index_file_name();
  if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = index_file_name_;
    index_file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_TableOptions::has_max_rows() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Table_TableOptions::set_has_max_rows() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Table_TableOptions::clear_has_max_rows() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Table_TableOptions::clear_max_rows() {
  max_rows_ = 0ULL;
  clear_has_max_rows();
}
inline ::google::protobuf::uint64 Table_TableOptions::max_rows() const {
  return max_rows_;
}
inline void Table_TableOptions::set_max_rows(::google::protobuf::uint64 value) {
  set_has_max_rows();
  max_rows_ = value;
}


inline bool Table_TableOptions::has_min_rows() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Table_TableOptions::set_has_min_rows() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Table_TableOptions::clear_has_min_rows() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Table_TableOptions::clear_min_rows() {
  min_rows_ = 0ULL;
  clear_has_min_rows();
}
inline ::google::protobuf::uint64 Table_TableOptions::min_rows() const {
  return min_rows_;
}
inline void Table_TableOptions::set_min_rows(::google::protobuf::uint64 value) {
  set_has_min_rows();
  min_rows_ = value;
}


inline bool Table_TableOptions::has_auto_increment_value() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Table_TableOptions::set_has_auto_increment_value() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Table_TableOptions::clear_has_auto_increment_value() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Table_TableOptions::clear_auto_increment_value() {
  auto_increment_value_ = 0ULL;
  clear_has_auto_increment_value();
}
inline ::google::protobuf::uint64 Table_TableOptions::auto_increment_value() const {
  return auto_increment_value_;
}
inline void Table_TableOptions::set_auto_increment_value(::google::protobuf::uint64 value) {
  set_has_auto_increment_value();
  auto_increment_value_ = value;
}


inline bool Table_TableOptions::has_avg_row_length() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Table_TableOptions::set_has_avg_row_length() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Table_TableOptions::clear_has_avg_row_length() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Table_TableOptions::clear_avg_row_length() {
  avg_row_length_ = 0u;
  clear_has_avg_row_length();
}
inline ::google::protobuf::uint32 Table_TableOptions::avg_row_length() const {
  return avg_row_length_;
}
inline void Table_TableOptions::set_avg_row_length(::google::protobuf::uint32 value) {
  set_has_avg_row_length();
  avg_row_length_ = value;
}


inline bool Table_TableOptions::has_block_size() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Table_TableOptions::set_has_block_size() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Table_TableOptions::clear_has_block_size() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Table_TableOptions::clear_block_size() {
  block_size_ = 0u;
  clear_has_block_size();
}
inline ::google::protobuf::uint32 Table_TableOptions::block_size() const {
  return block_size_;
}
inline void Table_TableOptions::set_block_size(::google::protobuf::uint32 value) {
  set_has_block_size();
  block_size_ = value;
}


inline bool Table_TableOptions::has_comment() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Table_TableOptions::set_has_comment() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Table_TableOptions::clear_has_comment() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Table_TableOptions::clear_comment() {
  if (comment_ != &::google::protobuf::internal::kEmptyString) {
    comment_->clear();
  }
  clear_has_comment();
}
inline const ::std::string& Table_TableOptions::comment() const {
  return *comment_;
}
inline void Table_TableOptions::set_comment(const ::std::string& value) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_TableOptions::set_comment(const char* value) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_TableOptions::set_comment(const char* value, size_t size) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_comment() {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  return comment_;
}
inline ::std::string* Table_TableOptions::release_comment() {
  clear_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = comment_;
    comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_TableOptions::has_pack_record() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Table_TableOptions::set_has_pack_record() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Table_TableOptions::clear_has_pack_record() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Table_TableOptions::clear_pack_record() {
  pack_record_ = false;
  clear_has_pack_record();
}
inline bool Table_TableOptions::pack_record() const {
  return pack_record_;
}
inline void Table_TableOptions::set_pack_record(bool value) {
  set_has_pack_record();
  pack_record_ = value;
}


inline bool Table_TableOptions::has_checksum() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Table_TableOptions::set_has_checksum() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Table_TableOptions::clear_has_checksum() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Table_TableOptions::clear_checksum() {
  checksum_ = false;
  clear_has_checksum();
}
inline bool Table_TableOptions::checksum() const {
  return checksum_;
}
inline void Table_TableOptions::set_checksum(bool value) {
  set_has_checksum();
  checksum_ = value;
}


inline bool Table_TableOptions::has_page_checksum() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Table_TableOptions::set_has_page_checksum() {
  _has_bits_[0] |= 0x00002000u;
}
inline void Table_TableOptions::clear_has_page_checksum() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void Table_TableOptions::clear_page_checksum() {
  page_checksum_ = false;
  clear_has_page_checksum();
}
inline bool Table_TableOptions::page_checksum() const {
  return page_checksum_;
}
inline void Table_TableOptions::set_page_checksum(bool value) {
  set_has_page_checksum();
  page_checksum_ = value;
}


inline bool Table_TableOptions::has_delay_key_write() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void Table_TableOptions::set_has_delay_key_write() {
  _has_bits_[0] |= 0x00004000u;
}
inline void Table_TableOptions::clear_has_delay_key_write() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void Table_TableOptions::clear_delay_key_write() {
  delay_key_write_ = false;
  clear_has_delay_key_write();
}
inline bool Table_TableOptions::delay_key_write() const {
  return delay_key_write_;
}
inline void Table_TableOptions::set_delay_key_write(bool value) {
  set_has_delay_key_write();
  delay_key_write_ = value;
}


inline bool Table_TableOptions::has_unused() const {
  return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void Table_TableOptions::set_has_unused() {
  _has_bits_[0] |= 0x00008000u;
}
inline void Table_TableOptions::clear_has_unused() {
  _has_bits_[0] &= ~0x00008000u;
}
inline void Table_TableOptions::clear_unused() {
  unused_ = false;
  clear_has_unused();
}
inline bool Table_TableOptions::unused() const {
  return unused_;
}
inline void Table_TableOptions::set_unused(bool value) {
  set_has_unused();
  unused_ = value;
}






inline bool Table_ForeignKeyConstraint::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_ForeignKeyConstraint::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_ForeignKeyConstraint::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_ForeignKeyConstraint::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Table_ForeignKeyConstraint::name() const {
  return *name_;
}
inline void Table_ForeignKeyConstraint::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_ForeignKeyConstraint::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_ForeignKeyConstraint::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_ForeignKeyConstraint::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Table_ForeignKeyConstraint::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline int Table_ForeignKeyConstraint::column_names_size() const {
  return column_names_.size();
}
inline void Table_ForeignKeyConstraint::clear_column_names() {
  column_names_.Clear();
}
inline const ::std::string& Table_ForeignKeyConstraint::column_names(int index) const {
  return column_names_.Get(index);
}
inline ::std::string* Table_ForeignKeyConstraint::mutable_column_names(int index) {
  return column_names_.Mutable(index);
}
inline void Table_ForeignKeyConstraint::set_column_names(int index, const ::std::string& value) {
  column_names_.Mutable(index)->assign(value);
}
inline void Table_ForeignKeyConstraint::set_column_names(int index, const char* value) {
  column_names_.Mutable(index)->assign(value);
}
inline void Table_ForeignKeyConstraint::set_column_names(int index, const char* value, size_t size) {
  column_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_ForeignKeyConstraint::add_column_names() {
  return column_names_.Add();
}
inline void Table_ForeignKeyConstraint::add_column_names(const ::std::string& value) {
  column_names_.Add()->assign(value);
}
inline void Table_ForeignKeyConstraint::add_column_names(const char* value) {
  column_names_.Add()->assign(value);
}
inline void Table_ForeignKeyConstraint::add_column_names(const char* value, size_t size) {
  column_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Table_ForeignKeyConstraint::column_names() const {
  return column_names_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Table_ForeignKeyConstraint::mutable_column_names() {
  return &column_names_;
}


inline bool Table_ForeignKeyConstraint::has_references_table_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_ForeignKeyConstraint::set_has_references_table_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_ForeignKeyConstraint::clear_has_references_table_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_ForeignKeyConstraint::clear_references_table_name() {
  if (references_table_name_ != &::google::protobuf::internal::kEmptyString) {
    references_table_name_->clear();
  }
  clear_has_references_table_name();
}
inline const ::std::string& Table_ForeignKeyConstraint::references_table_name() const {
  return *references_table_name_;
}
inline void Table_ForeignKeyConstraint::set_references_table_name(const ::std::string& value) {
  set_has_references_table_name();
  if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
    references_table_name_ = new ::std::string;
  }
  references_table_name_->assign(value);
}
inline void Table_ForeignKeyConstraint::set_references_table_name(const char* value) {
  set_has_references_table_name();
  if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
    references_table_name_ = new ::std::string;
  }
  references_table_name_->assign(value);
}
inline void Table_ForeignKeyConstraint::set_references_table_name(const char* value, size_t size) {
  set_has_references_table_name();
  if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
    references_table_name_ = new ::std::string;
  }
  references_table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_ForeignKeyConstraint::mutable_references_table_name() {
  set_has_references_table_name();
  if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
    references_table_name_ = new ::std::string;
  }
  return references_table_name_;
}
inline ::std::string* Table_ForeignKeyConstraint::release_references_table_name() {
  clear_has_references_table_name();
  if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = references_table_name_;
    references_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline int Table_ForeignKeyConstraint::references_columns_size() const {
  return references_columns_.size();
}
inline void Table_ForeignKeyConstraint::clear_references_columns() {
  references_columns_.Clear();
}
inline const ::std::string& Table_ForeignKeyConstraint::references_columns(int index) const {
  return references_columns_.Get(index);
}
inline ::std::string* Table_ForeignKeyConstraint::mutable_references_columns(int index) {
  return references_columns_.Mutable(index);
}
inline void Table_ForeignKeyConstraint::set_references_columns(int index, const ::std::string& value) {
  references_columns_.Mutable(index)->assign(value);
}
inline void Table_ForeignKeyConstraint::set_references_columns(int index, const char* value) {
  references_columns_.Mutable(index)->assign(value);
}
inline void Table_ForeignKeyConstraint::set_references_columns(int index, const char* value, size_t size) {
  references_columns_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_ForeignKeyConstraint::add_references_columns() {
  return references_columns_.Add();
}
inline void Table_ForeignKeyConstraint::add_references_columns(const ::std::string& value) {
  references_columns_.Add()->assign(value);
}
inline void Table_ForeignKeyConstraint::add_references_columns(const char* value) {
  references_columns_.Add()->assign(value);
}
inline void Table_ForeignKeyConstraint::add_references_columns(const char* value, size_t size) {
  references_columns_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Table_ForeignKeyConstraint::references_columns() const {
  return references_columns_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Table_ForeignKeyConstraint::mutable_references_columns() {
  return &references_columns_;
}


inline bool Table_ForeignKeyConstraint::has_match() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Table_ForeignKeyConstraint::set_has_match() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Table_ForeignKeyConstraint::clear_has_match() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Table_ForeignKeyConstraint::clear_match() {
  match_ = 0;
  clear_has_match();
}
inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint::match() const {
  return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption >(match_);
}
inline void Table_ForeignKeyConstraint::set_match(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption value) {
  !(!(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "./drizzled/message/table.pb.h", 3085) << "CHECK failed: " "::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value)" ": ";
  set_has_match();
  match_ = value;
}


inline bool Table_ForeignKeyConstraint::has_update_option() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Table_ForeignKeyConstraint::set_has_update_option() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Table_ForeignKeyConstraint::clear_has_update_option() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Table_ForeignKeyConstraint::clear_update_option() {
  update_option_ = 0;
  clear_has_update_option();
}
inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint::update_option() const {
  return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption >(update_option_);
}
inline void Table_ForeignKeyConstraint::set_update_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value) {
  !(!(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "./drizzled/message/table.pb.h", 3108) << "CHECK failed: " "::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value)" ": ";
  set_has_update_option();
  update_option_ = value;
}


inline bool Table_ForeignKeyConstraint::has_delete_option() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Table_ForeignKeyConstraint::set_has_delete_option() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Table_ForeignKeyConstraint::clear_has_delete_option() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Table_ForeignKeyConstraint::clear_delete_option() {
  delete_option_ = 0;
  clear_has_delete_option();
}
inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint::delete_option() const {
  return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption >(delete_option_);
}
inline void Table_ForeignKeyConstraint::set_delete_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value) {
  !(!(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "./drizzled/message/table.pb.h", 3131) << "CHECK failed: " "::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value)" ": ";
  set_has_delete_option();
  delete_option_ = value;
}






inline bool Table_Field_FieldOptions::has_default_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field_FieldOptions::set_has_default_value() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field_FieldOptions::clear_has_default_value() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field_FieldOptions::clear_default_value() {
  if (default_value_ != &::google::protobuf::internal::kEmptyString) {
    default_value_->clear();
  }
  clear_has_default_value();
}
inline const ::std::string& Table_Field_FieldOptions::default_value() const {
  return *default_value_;
}
inline void Table_Field_FieldOptions::set_default_value(const ::std::string& value) {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_value(const char* value) {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_value(const char* value, size_t size) {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_default_value() {
  set_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    default_value_ = new ::std::string;
  }
  return default_value_;
}
inline ::std::string* Table_Field_FieldOptions::release_default_value() {
  clear_has_default_value();
  if (default_value_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = default_value_;
    default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Field_FieldOptions::has_update_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Field_FieldOptions::set_has_update_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Field_FieldOptions::clear_has_update_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Field_FieldOptions::clear_update_value() {
  if (update_value_ != &::google::protobuf::internal::kEmptyString) {
    update_value_->clear();
  }
  clear_has_update_value();
}
inline const ::std::string& Table_Field_FieldOptions::update_value() const {
  return *update_value_;
}
inline void Table_Field_FieldOptions::set_update_value(const ::std::string& value) {
  set_has_update_value();
  if (update_value_ == &::google::protobuf::internal::kEmptyString) {
    update_value_ = new ::std::string;
  }
  update_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_update_value(const char* value) {
  set_has_update_value();
  if (update_value_ == &::google::protobuf::internal::kEmptyString) {
    update_value_ = new ::std::string;
  }
  update_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_update_value(const char* value, size_t size) {
  set_has_update_value();
  if (update_value_ == &::google::protobuf::internal::kEmptyString) {
    update_value_ = new ::std::string;
  }
  update_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_update_value() {
  set_has_update_value();
  if (update_value_ == &::google::protobuf::internal::kEmptyString) {
    update_value_ = new ::std::string;
  }
  return update_value_;
}
inline ::std::string* Table_Field_FieldOptions::release_update_value() {
  clear_has_update_value();
  if (update_value_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = update_value_;
    update_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Field_FieldOptions::has_default_null() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Field_FieldOptions::set_has_default_null() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Field_FieldOptions::clear_has_default_null() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Field_FieldOptions::clear_default_null() {
  default_null_ = false;
  clear_has_default_null();
}
inline bool Table_Field_FieldOptions::default_null() const {
  return default_null_;
}
inline void Table_Field_FieldOptions::set_default_null(bool value) {
  set_has_default_null();
  default_null_ = value;
}


inline bool Table_Field_FieldOptions::has_default_bin_value() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_Field_FieldOptions::set_has_default_bin_value() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_Field_FieldOptions::clear_has_default_bin_value() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_Field_FieldOptions::clear_default_bin_value() {
  if (default_bin_value_ != &::google::protobuf::internal::kEmptyString) {
    default_bin_value_->clear();
  }
  clear_has_default_bin_value();
}
inline const ::std::string& Table_Field_FieldOptions::default_bin_value() const {
  return *default_bin_value_;
}
inline void Table_Field_FieldOptions::set_default_bin_value(const ::std::string& value) {
  set_has_default_bin_value();
  if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
    default_bin_value_ = new ::std::string;
  }
  default_bin_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_bin_value(const char* value) {
  set_has_default_bin_value();
  if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
    default_bin_value_ = new ::std::string;
  }
  default_bin_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_bin_value(const void* value, size_t size) {
  set_has_default_bin_value();
  if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
    default_bin_value_ = new ::std::string;
  }
  default_bin_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_default_bin_value() {
  set_has_default_bin_value();
  if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
    default_bin_value_ = new ::std::string;
  }
  return default_bin_value_;
}
inline ::std::string* Table_Field_FieldOptions::release_default_bin_value() {
  clear_has_default_bin_value();
  if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = default_bin_value_;
    default_bin_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Field_FieldOptions::has_default_expression() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Table_Field_FieldOptions::set_has_default_expression() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Table_Field_FieldOptions::clear_has_default_expression() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Table_Field_FieldOptions::clear_default_expression() {
  if (default_expression_ != &::google::protobuf::internal::kEmptyString) {
    default_expression_->clear();
  }
  clear_has_default_expression();
}
inline const ::std::string& Table_Field_FieldOptions::default_expression() const {
  return *default_expression_;
}
inline void Table_Field_FieldOptions::set_default_expression(const ::std::string& value) {
  set_has_default_expression();
  if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
    default_expression_ = new ::std::string;
  }
  default_expression_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_expression(const char* value) {
  set_has_default_expression();
  if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
    default_expression_ = new ::std::string;
  }
  default_expression_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_expression(const char* value, size_t size) {
  set_has_default_expression();
  if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
    default_expression_ = new ::std::string;
  }
  default_expression_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_default_expression() {
  set_has_default_expression();
  if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
    default_expression_ = new ::std::string;
  }
  return default_expression_;
}
inline ::std::string* Table_Field_FieldOptions::release_default_expression() {
  clear_has_default_expression();
  if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = default_expression_;
    default_expression_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Field_FieldOptions::has_update_expression() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Table_Field_FieldOptions::set_has_update_expression() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Table_Field_FieldOptions::clear_has_update_expression() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Table_Field_FieldOptions::clear_update_expression() {
  if (update_expression_ != &::google::protobuf::internal::kEmptyString) {
    update_expression_->clear();
  }
  clear_has_update_expression();
}
inline const ::std::string& Table_Field_FieldOptions::update_expression() const {
  return *update_expression_;
}
inline void Table_Field_FieldOptions::set_update_expression(const ::std::string& value) {
  set_has_update_expression();
  if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
    update_expression_ = new ::std::string;
  }
  update_expression_->assign(value);
}
inline void Table_Field_FieldOptions::set_update_expression(const char* value) {
  set_has_update_expression();
  if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
    update_expression_ = new ::std::string;
  }
  update_expression_->assign(value);
}
inline void Table_Field_FieldOptions::set_update_expression(const char* value, size_t size) {
  set_has_update_expression();
  if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
    update_expression_ = new ::std::string;
  }
  update_expression_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_update_expression() {
  set_has_update_expression();
  if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
    update_expression_ = new ::std::string;
  }
  return update_expression_;
}
inline ::std::string* Table_Field_FieldOptions::release_update_expression() {
  clear_has_update_expression();
  if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = update_expression_;
    update_expression_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}






inline bool Table_Field_FieldConstraints::has_is_nullable() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field_FieldConstraints::set_has_is_nullable() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field_FieldConstraints::clear_has_is_nullable() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field_FieldConstraints::clear_is_nullable() {
  is_nullable_ = true;
  clear_has_is_nullable();
}
inline bool Table_Field_FieldConstraints::is_nullable() const {
  return is_nullable_;
}
inline void Table_Field_FieldConstraints::set_is_nullable(bool value) {
  set_has_is_nullable();
  is_nullable_ = value;
}


inline bool Table_Field_FieldConstraints::has_is_unsigned() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Field_FieldConstraints::set_has_is_unsigned() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Field_FieldConstraints::clear_has_is_unsigned() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Field_FieldConstraints::clear_is_unsigned() {
  is_unsigned_ = false;
  clear_has_is_unsigned();
}
inline bool Table_Field_FieldConstraints::is_unsigned() const {
  return is_unsigned_;
}
inline void Table_Field_FieldConstraints::set_is_unsigned(bool value) {
  set_has_is_unsigned();
  is_unsigned_ = value;
}


inline bool Table_Field_FieldConstraints::has_is_notnull() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Field_FieldConstraints::set_has_is_notnull() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Field_FieldConstraints::clear_has_is_notnull() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Field_FieldConstraints::clear_is_notnull() {
  is_notnull_ = false;
  clear_has_is_notnull();
}
inline bool Table_Field_FieldConstraints::is_notnull() const {
  return is_notnull_;
}
inline void Table_Field_FieldConstraints::set_is_notnull(bool value) {
  set_has_is_notnull();
  is_notnull_ = value;
}


inline bool Table_Field_FieldConstraints::has_is_unique() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_Field_FieldConstraints::set_has_is_unique() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_Field_FieldConstraints::clear_has_is_unique() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_Field_FieldConstraints::clear_is_unique() {
  is_unique_ = false;
  clear_has_is_unique();
}
inline bool Table_Field_FieldConstraints::is_unique() const {
  return is_unique_;
}
inline void Table_Field_FieldConstraints::set_is_unique(bool value) {
  set_has_is_unique();
  is_unique_ = value;
}


inline int Table_Field_FieldConstraints::expression_size() const {
  return expression_.size();
}
inline void Table_Field_FieldConstraints::clear_expression() {
  expression_.Clear();
}
inline const ::std::string& Table_Field_FieldConstraints::expression(int index) const {
  return expression_.Get(index);
}
inline ::std::string* Table_Field_FieldConstraints::mutable_expression(int index) {
  return expression_.Mutable(index);
}
inline void Table_Field_FieldConstraints::set_expression(int index, const ::std::string& value) {
  expression_.Mutable(index)->assign(value);
}
inline void Table_Field_FieldConstraints::set_expression(int index, const char* value) {
  expression_.Mutable(index)->assign(value);
}
inline void Table_Field_FieldConstraints::set_expression(int index, const char* value, size_t size) {
  expression_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldConstraints::add_expression() {
  return expression_.Add();
}
inline void Table_Field_FieldConstraints::add_expression(const ::std::string& value) {
  expression_.Add()->assign(value);
}
inline void Table_Field_FieldConstraints::add_expression(const char* value) {
  expression_.Add()->assign(value);
}
inline void Table_Field_FieldConstraints::add_expression(const char* value, size_t size) {
  expression_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Table_Field_FieldConstraints::expression() const {
  return expression_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Table_Field_FieldConstraints::mutable_expression() {
  return &expression_;
}






inline bool Table_Field_NumericFieldOptions::has_is_autoincrement() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field_NumericFieldOptions::set_has_is_autoincrement() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field_NumericFieldOptions::clear_has_is_autoincrement() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field_NumericFieldOptions::clear_is_autoincrement() {
  is_autoincrement_ = false;
  clear_has_is_autoincrement();
}
inline bool Table_Field_NumericFieldOptions::is_autoincrement() const {
  return is_autoincrement_;
}
inline void Table_Field_NumericFieldOptions::set_is_autoincrement(bool value) {
  set_has_is_autoincrement();
  is_autoincrement_ = value;
}


inline bool Table_Field_NumericFieldOptions::has_scale() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Field_NumericFieldOptions::set_has_scale() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Field_NumericFieldOptions::clear_has_scale() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Field_NumericFieldOptions::clear_scale() {
  scale_ = 0u;
  clear_has_scale();
}
inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::scale() const {
  return scale_;
}
inline void Table_Field_NumericFieldOptions::set_scale(::google::protobuf::uint32 value) {
  set_has_scale();
  scale_ = value;
}


inline bool Table_Field_NumericFieldOptions::has_precision() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Field_NumericFieldOptions::set_has_precision() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Field_NumericFieldOptions::clear_has_precision() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Field_NumericFieldOptions::clear_precision() {
  precision_ = 0u;
  clear_has_precision();
}
inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::precision() const {
  return precision_;
}
inline void Table_Field_NumericFieldOptions::set_precision(::google::protobuf::uint32 value) {
  set_has_precision();
  precision_ = value;
}






inline bool Table_Field_StringFieldOptions::has_is_fixed_width() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field_StringFieldOptions::set_has_is_fixed_width() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field_StringFieldOptions::clear_has_is_fixed_width() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field_StringFieldOptions::clear_is_fixed_width() {
  is_fixed_width_ = false;
  clear_has_is_fixed_width();
}
inline bool Table_Field_StringFieldOptions::is_fixed_width() const {
  return is_fixed_width_;
}
inline void Table_Field_StringFieldOptions::set_is_fixed_width(bool value) {
  set_has_is_fixed_width();
  is_fixed_width_ = value;
}


inline bool Table_Field_StringFieldOptions::has_length() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Field_StringFieldOptions::set_has_length() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Field_StringFieldOptions::clear_has_length() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Field_StringFieldOptions::clear_length() {
  length_ = 0u;
  clear_has_length();
}
inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::length() const {
  return length_;
}
inline void Table_Field_StringFieldOptions::set_length(::google::protobuf::uint32 value) {
  set_has_length();
  length_ = value;
}


inline bool Table_Field_StringFieldOptions::has_collation_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Field_StringFieldOptions::set_has_collation_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Field_StringFieldOptions::clear_has_collation_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Field_StringFieldOptions::clear_collation_id() {
  collation_id_ = 0u;
  clear_has_collation_id();
}
inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::collation_id() const {
  return collation_id_;
}
inline void Table_Field_StringFieldOptions::set_collation_id(::google::protobuf::uint32 value) {
  set_has_collation_id();
  collation_id_ = value;
}


inline bool Table_Field_StringFieldOptions::has_collation() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_Field_StringFieldOptions::set_has_collation() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_Field_StringFieldOptions::clear_has_collation() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_Field_StringFieldOptions::clear_collation() {
  if (collation_ != &::google::protobuf::internal::kEmptyString) {
    collation_->clear();
  }
  clear_has_collation();
}
inline const ::std::string& Table_Field_StringFieldOptions::collation() const {
  return *collation_;
}
inline void Table_Field_StringFieldOptions::set_collation(const ::std::string& value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_StringFieldOptions::set_collation(const char* value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_StringFieldOptions::set_collation(const char* value, size_t size) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_StringFieldOptions::mutable_collation() {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  return collation_;
}
inline ::std::string* Table_Field_StringFieldOptions::release_collation() {
  clear_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = collation_;
    collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}






inline bool Table_Field_EnumerationValues::has_collation_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field_EnumerationValues::set_has_collation_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field_EnumerationValues::clear_has_collation_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field_EnumerationValues::clear_collation_id() {
  collation_id_ = 0u;
  clear_has_collation_id();
}
inline ::google::protobuf::uint32 Table_Field_EnumerationValues::collation_id() const {
  return collation_id_;
}
inline void Table_Field_EnumerationValues::set_collation_id(::google::protobuf::uint32 value) {
  set_has_collation_id();
  collation_id_ = value;
}


inline bool Table_Field_EnumerationValues::has_collation() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Field_EnumerationValues::set_has_collation() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Field_EnumerationValues::clear_has_collation() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Field_EnumerationValues::clear_collation() {
  if (collation_ != &::google::protobuf::internal::kEmptyString) {
    collation_->clear();
  }
  clear_has_collation();
}
inline const ::std::string& Table_Field_EnumerationValues::collation() const {
  return *collation_;
}
inline void Table_Field_EnumerationValues::set_collation(const ::std::string& value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_EnumerationValues::set_collation(const char* value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_EnumerationValues::set_collation(const char* value, size_t size) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_EnumerationValues::mutable_collation() {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  return collation_;
}
inline ::std::string* Table_Field_EnumerationValues::release_collation() {
  clear_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = collation_;
    collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline int Table_Field_EnumerationValues::field_value_size() const {
  return field_value_.size();
}
inline void Table_Field_EnumerationValues::clear_field_value() {
  field_value_.Clear();
}
inline const ::std::string& Table_Field_EnumerationValues::field_value(int index) const {
  return field_value_.Get(index);
}
inline ::std::string* Table_Field_EnumerationValues::mutable_field_value(int index) {
  return field_value_.Mutable(index);
}
inline void Table_Field_EnumerationValues::set_field_value(int index, const ::std::string& value) {
  field_value_.Mutable(index)->assign(value);
}
inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value) {
  field_value_.Mutable(index)->assign(value);
}
inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value, size_t size) {
  field_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_EnumerationValues::add_field_value() {
  return field_value_.Add();
}
inline void Table_Field_EnumerationValues::add_field_value(const ::std::string& value) {
  field_value_.Add()->assign(value);
}
inline void Table_Field_EnumerationValues::add_field_value(const char* value) {
  field_value_.Add()->assign(value);
}
inline void Table_Field_EnumerationValues::add_field_value(const char* value, size_t size) {
  field_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Table_Field_EnumerationValues::field_value() const {
  return field_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Table_Field_EnumerationValues::mutable_field_value() {
  return &field_value_;
}






inline bool Table_Field_TimeFieldOptions::has_microseconds() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field_TimeFieldOptions::set_has_microseconds() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field_TimeFieldOptions::clear_has_microseconds() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field_TimeFieldOptions::clear_microseconds() {
  microseconds_ = false;
  clear_has_microseconds();
}
inline bool Table_Field_TimeFieldOptions::microseconds() const {
  return microseconds_;
}
inline void Table_Field_TimeFieldOptions::set_microseconds(bool value) {
  set_has_microseconds();
  microseconds_ = value;
}






inline bool Table_Field::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Field::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Field::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Field::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Table_Field::name() const {
  return *name_;
}
inline void Table_Field::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Field::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Field::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Table_Field::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Field::has_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Field::set_has_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Field::clear_has_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Field::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::drizzled::message::Table_Field_FieldType Table_Field::type() const {
  return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
}
inline void Table_Field::set_type(::drizzled::message::Table_Field_FieldType value) {
  !(!(::drizzled::message::Table_Field_FieldType_IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "./drizzled/message/table.pb.h", 4020) << "CHECK failed: " "::drizzled::message::Table_Field_FieldType_IsValid(value)" ": ";
  set_has_type();
  type_ = value;
}


inline bool Table_Field::has_options() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Field::set_has_options() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Field::clear_has_options() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Field::clear_options() {
  if (options_ != __null) options_->::drizzled::message::Table_Field_FieldOptions::Clear();
  clear_has_options();
}
inline const ::drizzled::message::Table_Field_FieldOptions& Table_Field::options() const {
  return options_ != __null ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Table_Field_FieldOptions* Table_Field::mutable_options() {
  set_has_options();
  if (options_ == __null) options_ = new ::drizzled::message::Table_Field_FieldOptions;
  return options_;
}
inline ::drizzled::message::Table_Field_FieldOptions* Table_Field::release_options() {
  clear_has_options();
  ::drizzled::message::Table_Field_FieldOptions* temp = options_;
  options_ = __null;
  return temp;
}


inline bool Table_Field::has_constraints() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_Field::set_has_constraints() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_Field::clear_has_constraints() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_Field::clear_constraints() {
  if (constraints_ != __null) constraints_->::drizzled::message::Table_Field_FieldConstraints::Clear();
  clear_has_constraints();
}
inline const ::drizzled::message::Table_Field_FieldConstraints& Table_Field::constraints() const {
  return constraints_ != __null ? *constraints_ : *default_instance_->constraints_;
}
inline ::drizzled::message::Table_Field_FieldConstraints* Table_Field::mutable_constraints() {
  set_has_constraints();
  if (constraints_ == __null) constraints_ = new ::drizzled::message::Table_Field_FieldConstraints;
  return constraints_;
}
inline ::drizzled::message::Table_Field_FieldConstraints* Table_Field::release_constraints() {
  clear_has_constraints();
  ::drizzled::message::Table_Field_FieldConstraints* temp = constraints_;
  constraints_ = __null;
  return temp;
}


inline bool Table_Field::has_numeric_options() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Table_Field::set_has_numeric_options() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Table_Field::clear_has_numeric_options() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Table_Field::clear_numeric_options() {
  if (numeric_options_ != __null) numeric_options_->::drizzled::message::Table_Field_NumericFieldOptions::Clear();
  clear_has_numeric_options();
}
inline const ::drizzled::message::Table_Field_NumericFieldOptions& Table_Field::numeric_options() const {
  return numeric_options_ != __null ? *numeric_options_ : *default_instance_->numeric_options_;
}
inline ::drizzled::message::Table_Field_NumericFieldOptions* Table_Field::mutable_numeric_options() {
  set_has_numeric_options();
  if (numeric_options_ == __null) numeric_options_ = new ::drizzled::message::Table_Field_NumericFieldOptions;
  return numeric_options_;
}
inline ::drizzled::message::Table_Field_NumericFieldOptions* Table_Field::release_numeric_options() {
  clear_has_numeric_options();
  ::drizzled::message::Table_Field_NumericFieldOptions* temp = numeric_options_;
  numeric_options_ = __null;
  return temp;
}


inline bool Table_Field::has_string_options() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Table_Field::set_has_string_options() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Table_Field::clear_has_string_options() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Table_Field::clear_string_options() {
  if (string_options_ != __null) string_options_->::drizzled::message::Table_Field_StringFieldOptions::Clear();
  clear_has_string_options();
}
inline const ::drizzled::message::Table_Field_StringFieldOptions& Table_Field::string_options() const {
  return string_options_ != __null ? *string_options_ : *default_instance_->string_options_;
}
inline ::drizzled::message::Table_Field_StringFieldOptions* Table_Field::mutable_string_options() {
  set_has_string_options();
  if (string_options_ == __null) string_options_ = new ::drizzled::message::Table_Field_StringFieldOptions;
  return string_options_;
}
inline ::drizzled::message::Table_Field_StringFieldOptions* Table_Field::release_string_options() {
  clear_has_string_options();
  ::drizzled::message::Table_Field_StringFieldOptions* temp = string_options_;
  string_options_ = __null;
  return temp;
}


inline bool Table_Field::has_time_options() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Table_Field::set_has_time_options() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Table_Field::clear_has_time_options() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Table_Field::clear_time_options() {
  if (time_options_ != __null) time_options_->::drizzled::message::Table_Field_TimeFieldOptions::Clear();
  clear_has_time_options();
}
inline const ::drizzled::message::Table_Field_TimeFieldOptions& Table_Field::time_options() const {
  return time_options_ != __null ? *time_options_ : *default_instance_->time_options_;
}
inline ::drizzled::message::Table_Field_TimeFieldOptions* Table_Field::mutable_time_options() {
  set_has_time_options();
  if (time_options_ == __null) time_options_ = new ::drizzled::message::Table_Field_TimeFieldOptions;
  return time_options_;
}
inline ::drizzled::message::Table_Field_TimeFieldOptions* Table_Field::release_time_options() {
  clear_has_time_options();
  ::drizzled::message::Table_Field_TimeFieldOptions* temp = time_options_;
  time_options_ = __null;
  return temp;
}


inline bool Table_Field::has_comment() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Table_Field::set_has_comment() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Table_Field::clear_has_comment() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Table_Field::clear_comment() {
  if (comment_ != &::google::protobuf::internal::kEmptyString) {
    comment_->clear();
  }
  clear_has_comment();
}
inline const ::std::string& Table_Field::comment() const {
  return *comment_;
}
inline void Table_Field::set_comment(const ::std::string& value) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Field::set_comment(const char* value) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Field::set_comment(const char* value, size_t size) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field::mutable_comment() {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  return comment_;
}
inline ::std::string* Table_Field::release_comment() {
  clear_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = comment_;
    comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Field::has_enumeration_values() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Table_Field::set_has_enumeration_values() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Table_Field::clear_has_enumeration_values() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Table_Field::clear_enumeration_values() {
  if (enumeration_values_ != __null) enumeration_values_->::drizzled::message::Table_Field_EnumerationValues::Clear();
  clear_has_enumeration_values();
}
inline const ::drizzled::message::Table_Field_EnumerationValues& Table_Field::enumeration_values() const {
  return enumeration_values_ != __null ? *enumeration_values_ : *default_instance_->enumeration_values_;
}
inline ::drizzled::message::Table_Field_EnumerationValues* Table_Field::mutable_enumeration_values() {
  set_has_enumeration_values();
  if (enumeration_values_ == __null) enumeration_values_ = new ::drizzled::message::Table_Field_EnumerationValues;
  return enumeration_values_;
}
inline ::drizzled::message::Table_Field_EnumerationValues* Table_Field::release_enumeration_values() {
  clear_has_enumeration_values();
  ::drizzled::message::Table_Field_EnumerationValues* temp = enumeration_values_;
  enumeration_values_ = __null;
  return temp;
}






inline bool Table_Index_IndexPart::has_fieldnr() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Index_IndexPart::set_has_fieldnr() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Index_IndexPart::clear_has_fieldnr() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Index_IndexPart::clear_fieldnr() {
  fieldnr_ = 0u;
  clear_has_fieldnr();
}
inline ::google::protobuf::uint32 Table_Index_IndexPart::fieldnr() const {
  return fieldnr_;
}
inline void Table_Index_IndexPart::set_fieldnr(::google::protobuf::uint32 value) {
  set_has_fieldnr();
  fieldnr_ = value;
}


inline bool Table_Index_IndexPart::has_compare_length() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Index_IndexPart::set_has_compare_length() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Index_IndexPart::clear_has_compare_length() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Index_IndexPart::clear_compare_length() {
  compare_length_ = 0u;
  clear_has_compare_length();
}
inline ::google::protobuf::uint32 Table_Index_IndexPart::compare_length() const {
  return compare_length_;
}
inline void Table_Index_IndexPart::set_compare_length(::google::protobuf::uint32 value) {
  set_has_compare_length();
  compare_length_ = value;
}


inline bool Table_Index_IndexPart::has_in_reverse_order() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Index_IndexPart::set_has_in_reverse_order() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Index_IndexPart::clear_has_in_reverse_order() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Index_IndexPart::clear_in_reverse_order() {
  in_reverse_order_ = false;
  clear_has_in_reverse_order();
}
inline bool Table_Index_IndexPart::in_reverse_order() const {
  return in_reverse_order_;
}
inline void Table_Index_IndexPart::set_in_reverse_order(bool value) {
  set_has_in_reverse_order();
  in_reverse_order_ = value;
}






inline bool Table_Index_Options::has_pack_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Index_Options::set_has_pack_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Index_Options::clear_has_pack_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Index_Options::clear_pack_key() {
  pack_key_ = false;
  clear_has_pack_key();
}
inline bool Table_Index_Options::pack_key() const {
  return pack_key_;
}
inline void Table_Index_Options::set_pack_key(bool value) {
  set_has_pack_key();
  pack_key_ = value;
}


inline bool Table_Index_Options::has_binary_pack_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Index_Options::set_has_binary_pack_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Index_Options::clear_has_binary_pack_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Index_Options::clear_binary_pack_key() {
  binary_pack_key_ = false;
  clear_has_binary_pack_key();
}
inline bool Table_Index_Options::binary_pack_key() const {
  return binary_pack_key_;
}
inline void Table_Index_Options::set_binary_pack_key(bool value) {
  set_has_binary_pack_key();
  binary_pack_key_ = value;
}


inline bool Table_Index_Options::has_var_length_key() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Index_Options::set_has_var_length_key() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Index_Options::clear_has_var_length_key() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Index_Options::clear_var_length_key() {
  var_length_key_ = false;
  clear_has_var_length_key();
}
inline bool Table_Index_Options::var_length_key() const {
  return var_length_key_;
}
inline void Table_Index_Options::set_var_length_key(bool value) {
  set_has_var_length_key();
  var_length_key_ = value;
}


inline bool Table_Index_Options::has_null_part_key() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_Index_Options::set_has_null_part_key() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_Index_Options::clear_has_null_part_key() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_Index_Options::clear_null_part_key() {
  null_part_key_ = false;
  clear_has_null_part_key();
}
inline bool Table_Index_Options::null_part_key() const {
  return null_part_key_;
}
inline void Table_Index_Options::set_null_part_key(bool value) {
  set_has_null_part_key();
  null_part_key_ = value;
}


inline bool Table_Index_Options::has_key_block_size() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Table_Index_Options::set_has_key_block_size() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Table_Index_Options::clear_has_key_block_size() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Table_Index_Options::clear_key_block_size() {
  key_block_size_ = 0u;
  clear_has_key_block_size();
}
inline ::google::protobuf::uint32 Table_Index_Options::key_block_size() const {
  return key_block_size_;
}
inline void Table_Index_Options::set_key_block_size(::google::protobuf::uint32 value) {
  set_has_key_block_size();
  key_block_size_ = value;
}


inline bool Table_Index_Options::has_has_partial_segments() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Table_Index_Options::set_has_has_partial_segments() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Table_Index_Options::clear_has_has_partial_segments() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Table_Index_Options::clear_has_partial_segments() {
  has_partial_segments_ = false;
  clear_has_has_partial_segments();
}
inline bool Table_Index_Options::has_partial_segments() const {
  return has_partial_segments_;
}
inline void Table_Index_Options::set_has_partial_segments(bool value) {
  set_has_has_partial_segments();
  has_partial_segments_ = value;
}


inline bool Table_Index_Options::has_auto_generated_key() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Table_Index_Options::set_has_auto_generated_key() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Table_Index_Options::clear_has_auto_generated_key() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Table_Index_Options::clear_auto_generated_key() {
  auto_generated_key_ = false;
  clear_has_auto_generated_key();
}
inline bool Table_Index_Options::auto_generated_key() const {
  return auto_generated_key_;
}
inline void Table_Index_Options::set_auto_generated_key(bool value) {
  set_has_auto_generated_key();
  auto_generated_key_ = value;
}






inline bool Table_Index::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table_Index::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table_Index::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table_Index::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Table_Index::name() const {
  return *name_;
}
inline void Table_Index::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Index::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Index::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Index::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Table_Index::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table_Index::has_is_primary() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table_Index::set_has_is_primary() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table_Index::clear_has_is_primary() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table_Index::clear_is_primary() {
  is_primary_ = false;
  clear_has_is_primary();
}
inline bool Table_Index::is_primary() const {
  return is_primary_;
}
inline void Table_Index::set_is_primary(bool value) {
  set_has_is_primary();
  is_primary_ = value;
}


inline bool Table_Index::has_is_unique() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table_Index::set_has_is_unique() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table_Index::clear_has_is_unique() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table_Index::clear_is_unique() {
  is_unique_ = false;
  clear_has_is_unique();
}
inline bool Table_Index::is_unique() const {
  return is_unique_;
}
inline void Table_Index::set_is_unique(bool value) {
  set_has_is_unique();
  is_unique_ = value;
}


inline bool Table_Index::has_type() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table_Index::set_has_type() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table_Index::clear_has_type() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table_Index::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::drizzled::message::Table_Index_IndexType Table_Index::type() const {
  return static_cast< ::drizzled::message::Table_Index_IndexType >(type_);
}
inline void Table_Index::set_type(::drizzled::message::Table_Index_IndexType value) {
  !(!(::drizzled::message::Table_Index_IndexType_IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "./drizzled/message/table.pb.h", 4609) << "CHECK failed: " "::drizzled::message::Table_Index_IndexType_IsValid(value)" ": ";
  set_has_type();
  type_ = value;
}


inline bool Table_Index::has_key_length() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Table_Index::set_has_key_length() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Table_Index::clear_has_key_length() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Table_Index::clear_key_length() {
  key_length_ = 0u;
  clear_has_key_length();
}
inline ::google::protobuf::uint32 Table_Index::key_length() const {
  return key_length_;
}
inline void Table_Index::set_key_length(::google::protobuf::uint32 value) {
  set_has_key_length();
  key_length_ = value;
}


inline int Table_Index::index_part_size() const {
  return index_part_.size();
}
inline void Table_Index::clear_index_part() {
  index_part_.Clear();
}
inline const ::drizzled::message::Table_Index_IndexPart& Table_Index::index_part(int index) const {
  return index_part_.Get(index);
}
inline ::drizzled::message::Table_Index_IndexPart* Table_Index::mutable_index_part(int index) {
  return index_part_.Mutable(index);
}
inline ::drizzled::message::Table_Index_IndexPart* Table_Index::add_index_part() {
  return index_part_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
Table_Index::index_part() const {
  return index_part_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
Table_Index::mutable_index_part() {
  return &index_part_;
}


inline bool Table_Index::has_options() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Table_Index::set_has_options() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Table_Index::clear_has_options() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Table_Index::clear_options() {
  if (options_ != __null) options_->::drizzled::message::Table_Index_Options::Clear();
  clear_has_options();
}
inline const ::drizzled::message::Table_Index_Options& Table_Index::options() const {
  return options_ != __null ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Table_Index_Options* Table_Index::mutable_options() {
  set_has_options();
  if (options_ == __null) options_ = new ::drizzled::message::Table_Index_Options;
  return options_;
}
inline ::drizzled::message::Table_Index_Options* Table_Index::release_options() {
  clear_has_options();
  ::drizzled::message::Table_Index_Options* temp = options_;
  options_ = __null;
  return temp;
}


inline bool Table_Index::has_comment() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Table_Index::set_has_comment() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Table_Index::clear_has_comment() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Table_Index::clear_comment() {
  if (comment_ != &::google::protobuf::internal::kEmptyString) {
    comment_->clear();
  }
  clear_has_comment();
}
inline const ::std::string& Table_Index::comment() const {
  return *comment_;
}
inline void Table_Index::set_comment(const ::std::string& value) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Index::set_comment(const char* value) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Index::set_comment(const char* value, size_t size) {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  comment_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Index::mutable_comment() {
  set_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    comment_ = new ::std::string;
  }
  return comment_;
}
inline ::std::string* Table_Index::release_comment() {
  clear_has_comment();
  if (comment_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = comment_;
    comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}






inline bool Table::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Table::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Table::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Table::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Table::name() const {
  return *name_;
}
inline void Table::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Table::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table::has_schema() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Table::set_has_schema() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Table::clear_has_schema() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Table::clear_schema() {
  if (schema_ != &::google::protobuf::internal::kEmptyString) {
    schema_->clear();
  }
  clear_has_schema();
}
inline const ::std::string& Table::schema() const {
  return *schema_;
}
inline void Table::set_schema(const ::std::string& value) {
  set_has_schema();
  if (schema_ == &::google::protobuf::internal::kEmptyString) {
    schema_ = new ::std::string;
  }
  schema_->assign(value);
}
inline void Table::set_schema(const char* value) {
  set_has_schema();
  if (schema_ == &::google::protobuf::internal::kEmptyString) {
    schema_ = new ::std::string;
  }
  schema_->assign(value);
}
inline void Table::set_schema(const char* value, size_t size) {
  set_has_schema();
  if (schema_ == &::google::protobuf::internal::kEmptyString) {
    schema_ = new ::std::string;
  }
  schema_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_schema() {
  set_has_schema();
  if (schema_ == &::google::protobuf::internal::kEmptyString) {
    schema_ = new ::std::string;
  }
  return schema_;
}
inline ::std::string* Table::release_schema() {
  clear_has_schema();
  if (schema_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = schema_;
    schema_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table::has_type() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Table::set_has_type() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Table::clear_has_type() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Table::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::drizzled::message::Table_TableType Table::type() const {
  return static_cast< ::drizzled::message::Table_TableType >(type_);
}
inline void Table::set_type(::drizzled::message::Table_TableType value) {
  !(!(::drizzled::message::Table_TableType_IsValid(value))) ? (void)0 : ::google::protobuf::internal::LogFinisher() = ::google::protobuf::internal::LogMessage( ::google::protobuf::LOGLEVEL_FATAL, "./drizzled/message/table.pb.h", 4886) << "CHECK failed: " "::drizzled::message::Table_TableType_IsValid(value)" ": ";
  set_has_type();
  type_ = value;
}


inline bool Table::has_engine() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Table::set_has_engine() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Table::clear_has_engine() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Table::clear_engine() {
  if (engine_ != __null) engine_->::drizzled::message::Engine::Clear();
  clear_has_engine();
}
inline const ::drizzled::message::Engine& Table::engine() const {
  return engine_ != __null ? *engine_ : *default_instance_->engine_;
}
inline ::drizzled::message::Engine* Table::mutable_engine() {
  set_has_engine();
  if (engine_ == __null) engine_ = new ::drizzled::message::Engine;
  return engine_;
}
inline ::drizzled::message::Engine* Table::release_engine() {
  clear_has_engine();
  ::drizzled::message::Engine* temp = engine_;
  engine_ = __null;
  return temp;
}


inline int Table::field_size() const {
  return field_.size();
}
inline void Table::clear_field() {
  field_.Clear();
}
inline const ::drizzled::message::Table_Field& Table::field(int index) const {
  return field_.Get(index);
}
inline ::drizzled::message::Table_Field* Table::mutable_field(int index) {
  return field_.Mutable(index);
}
inline ::drizzled::message::Table_Field* Table::add_field() {
  return field_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
Table::field() const {
  return field_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
Table::mutable_field() {
  return &field_;
}


inline int Table::indexes_size() const {
  return indexes_.size();
}
inline void Table::clear_indexes() {
  indexes_.Clear();
}
inline const ::drizzled::message::Table_Index& Table::indexes(int index) const {
  return indexes_.Get(index);
}
inline ::drizzled::message::Table_Index* Table::mutable_indexes(int index) {
  return indexes_.Mutable(index);
}
inline ::drizzled::message::Table_Index* Table::add_indexes() {
  return indexes_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
Table::indexes() const {
  return indexes_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
Table::mutable_indexes() {
  return &indexes_;
}


inline int Table::fk_constraint_size() const {
  return fk_constraint_.size();
}
inline void Table::clear_fk_constraint() {
  fk_constraint_.Clear();
}
inline const ::drizzled::message::Table_ForeignKeyConstraint& Table::fk_constraint(int index) const {
  return fk_constraint_.Get(index);
}
inline ::drizzled::message::Table_ForeignKeyConstraint* Table::mutable_fk_constraint(int index) {
  return fk_constraint_.Mutable(index);
}
inline ::drizzled::message::Table_ForeignKeyConstraint* Table::add_fk_constraint() {
  return fk_constraint_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
Table::fk_constraint() const {
  return fk_constraint_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
Table::mutable_fk_constraint() {
  return &fk_constraint_;
}


inline bool Table::has_options() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Table::set_has_options() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Table::clear_has_options() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Table::clear_options() {
  if (options_ != __null) options_->::drizzled::message::Table_TableOptions::Clear();
  clear_has_options();
}
inline const ::drizzled::message::Table_TableOptions& Table::options() const {
  return options_ != __null ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Table_TableOptions* Table::mutable_options() {
  set_has_options();
  if (options_ == __null) options_ = new ::drizzled::message::Table_TableOptions;
  return options_;
}
inline ::drizzled::message::Table_TableOptions* Table::release_options() {
  clear_has_options();
  ::drizzled::message::Table_TableOptions* temp = options_;
  options_ = __null;
  return temp;
}


inline bool Table::has_creation_timestamp() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Table::set_has_creation_timestamp() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Table::clear_has_creation_timestamp() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Table::clear_creation_timestamp() {
  creation_timestamp_ = 0ULL;
  clear_has_creation_timestamp();
}
inline ::google::protobuf::uint64 Table::creation_timestamp() const {
  return creation_timestamp_;
}
inline void Table::set_creation_timestamp(::google::protobuf::uint64 value) {
  set_has_creation_timestamp();
  creation_timestamp_ = value;
}


inline bool Table::has_update_timestamp() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Table::set_has_update_timestamp() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Table::clear_has_update_timestamp() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Table::clear_update_timestamp() {
  update_timestamp_ = 0ULL;
  clear_has_update_timestamp();
}
inline ::google::protobuf::uint64 Table::update_timestamp() const {
  return update_timestamp_;
}
inline void Table::set_update_timestamp(::google::protobuf::uint64 value) {
  set_has_update_timestamp();
  update_timestamp_ = value;
}


inline bool Table::has_catalog() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Table::set_has_catalog() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Table::clear_has_catalog() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Table::clear_catalog() {
  if (catalog_ != &::google::protobuf::internal::kEmptyString) {
    catalog_->clear();
  }
  clear_has_catalog();
}
inline const ::std::string& Table::catalog() const {
  return *catalog_;
}
inline void Table::set_catalog(const ::std::string& value) {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(value);
}
inline void Table::set_catalog(const char* value) {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(value);
}
inline void Table::set_catalog(const char* value, size_t size) {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_catalog() {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  return catalog_;
}
inline ::std::string* Table::release_catalog() {
  clear_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = catalog_;
    catalog_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table::has_uuid() const {
  return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void Table::set_has_uuid() {
  _has_bits_[0] |= 0x00000800u;
}
inline void Table::clear_has_uuid() {
  _has_bits_[0] &= ~0x00000800u;
}
inline void Table::clear_uuid() {
  if (uuid_ != &::google::protobuf::internal::kEmptyString) {
    uuid_->clear();
  }
  clear_has_uuid();
}
inline const ::std::string& Table::uuid() const {
  return *uuid_;
}
inline void Table::set_uuid(const ::std::string& value) {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  uuid_->assign(value);
}
inline void Table::set_uuid(const char* value) {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  uuid_->assign(value);
}
inline void Table::set_uuid(const char* value, size_t size) {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  uuid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_uuid() {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  return uuid_;
}
inline ::std::string* Table::release_uuid() {
  clear_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = uuid_;
    uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Table::has_version() const {
  return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void Table::set_has_version() {
  _has_bits_[0] |= 0x00001000u;
}
inline void Table::clear_has_version() {
  _has_bits_[0] &= ~0x00001000u;
}
inline void Table::clear_version() {
  version_ = 0ULL;
  clear_has_version();
}
inline ::google::protobuf::uint64 Table::version() const {
  return version_;
}
inline void Table::set_version(::google::protobuf::uint64 value) {
  set_has_version();
  version_ = value;
}


inline bool Table::has_replication_options() const {
  return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void Table::set_has_replication_options() {
  _has_bits_[0] |= 0x00002000u;
}
inline void Table::clear_has_replication_options() {
  _has_bits_[0] &= ~0x00002000u;
}
inline void Table::clear_replication_options() {
  if (replication_options_ != __null) replication_options_->::drizzled::message::ReplicationOptions::Clear();
  clear_has_replication_options();
}
inline const ::drizzled::message::ReplicationOptions& Table::replication_options() const {
  return replication_options_ != __null ? *replication_options_ : *default_instance_->replication_options_;
}
inline ::drizzled::message::ReplicationOptions* Table::mutable_replication_options() {
  set_has_replication_options();
  if (replication_options_ == __null) replication_options_ = new ::drizzled::message::ReplicationOptions;
  return replication_options_;
}
inline ::drizzled::message::ReplicationOptions* Table::release_replication_options() {
  clear_has_replication_options();
  ::drizzled::message::ReplicationOptions* temp = replication_options_;
  replication_options_ = __null;
  return temp;
}


inline bool Table::has_access() const {
  return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void Table::set_has_access() {
  _has_bits_[0] |= 0x00004000u;
}
inline void Table::clear_has_access() {
  _has_bits_[0] &= ~0x00004000u;
}
inline void Table::clear_access() {
  if (access_ != __null) access_->::drizzled::message::Access::Clear();
  clear_has_access();
}
inline const ::drizzled::message::Access& Table::access() const {
  return access_ != __null ? *access_ : *default_instance_->access_;
}
inline ::drizzled::message::Access* Table::mutable_access() {
  set_has_access();
  if (access_ == __null) access_ = new ::drizzled::message::Access;
  return access_;
}
inline ::drizzled::message::Access* Table::release_access() {
  clear_has_access();
  ::drizzled::message::Access* temp = access_;
  access_ = __null;
  return temp;
}






inline int AddedFields::added_field_size() const {
  return added_field_.size();
}
inline void AddedFields::clear_added_field() {
  added_field_.Clear();
}
inline const ::drizzled::message::Table_Field& AddedFields::added_field(int index) const {
  return added_field_.Get(index);
}
inline ::drizzled::message::Table_Field* AddedFields::mutable_added_field(int index) {
  return added_field_.Mutable(index);
}
inline ::drizzled::message::Table_Field* AddedFields::add_added_field() {
  return added_field_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
AddedFields::added_field() const {
  return added_field_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
AddedFields::mutable_added_field() {
  return &added_field_;
}




}
}


namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption>() {
  return ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption>() {
  return ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Field_FieldType>() {
  return ::drizzled::message::Table_Field_FieldType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Index_IndexType>() {
  return ::drizzled::message::Table_Index_IndexType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_TableType>() {
  return ::drizzled::message::Table_TableType_descriptor();
}

}
}
# 38 "./drizzled/identifier/table.h" 2

# 1 "./drizzled/util/backtrace.h" 1
# 21 "./drizzled/util/backtrace.h"
       



# 1 "/usr/include/c++/4.8/cstddef" 1 3
# 39 "/usr/include/c++/4.8/cstddef" 3
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 26 "./drizzled/util/backtrace.h" 2

namespace drizzled
{

namespace util
{

__attribute__ ((visibility("default")))
void custom_backtrace(const char *file, int line, const char *func, size_t depth= 0);

}
}
# 40 "./drizzled/identifier/table.h" 2



# 1 "/usr/include/assert.h" 1 3 4
# 44 "./drizzled/identifier/table.h" 2






# 1 "/usr/include/boost/functional/hash.hpp" 1 3 4





# 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
# 7 "/usr/include/boost/functional/hash.hpp" 2 3 4
# 51 "./drizzled/identifier/table.h" 2





namespace drizzled {
namespace identifier {

class __attribute__ ((visibility("default"))) Table : public Schema
{
public:
  typedef message::Table::TableType Type;

  class Key
  {
    std::vector<char> key_buffer;
    size_t hash_value;
    size_t schema_offset;
    size_t table_offset;

  public:

    Key() :
      hash_value(0),
      schema_offset(0),
      table_offset(0)
    {
    }

    const char *vector() const
    {
      return &key_buffer[0];
    }

    const char *schema_name() const
    {
      return &key_buffer[0] +schema_offset;
    }

    const char *table_name() const
    {
      return &key_buffer[0] +table_offset;
    }

    size_t hash() const
    {
      return hash_value;
    }

    std::vector<char> &vectorPtr()
    {
      return key_buffer;
    }

    void set(size_t resize_arg, const std::string &catalog_arg, const std::string &schema_arg, const std::string &table_arg);

    friend bool operator==(const Key &left, const Key &right)
    {
      if (left.hash_value == right.hash_value and left.key_buffer.size() == right.key_buffer.size())
      {
        if (memcmp(&left.key_buffer[0], &right.key_buffer[0], left.key_buffer.size()) == 0)
          return true;
      }

      return false;
    }

    friend bool operator<(const Key &left, const Key &right)
    {
      return left.key_buffer < right.key_buffer;
    }

    size_t size() const
    {
      return key_buffer.size();
    }

    size_t getHashValue() const
    {
      return hash_value;
    }
  };

private:

  Type type;
  std::string path;
  std::string key_path;
  std::string table_name;
  Key key;
  size_t hash_value;

  void init();

  size_t getKeySize() const
  {
    return getCatalogName().size() + getSchemaName().size() + getTableName().size() + 3;
  }

public:

  Table(const drizzled::Table &table);

  Table(const identifier::Schema &schema,
        const std::string &table_name_arg,
        Type tmp_arg= message::Table::STANDARD);

  Table(const std::string &db_arg,
        const std::string &table_name_arg,
        Type tmp_arg= message::Table::STANDARD);

  Table(const std::string &schema_name_arg,
        const std::string &table_name_arg,
        const std::string &path_arg );

  using Schema::compare;

  bool isTmp() const
  {
    if (type == message::Table::TEMPORARY || type == message::Table::INTERNAL)
      return true;

    return false;
  }

  static bool isView(message::Table::TableType arg)
  {
    switch (arg)
    {
    default:
    case message::Table::STANDARD:
    case message::Table::TEMPORARY:
    case message::Table::INTERNAL:
      break;
    case message::Table::FUNCTION:
      return true;
    }

    return false;
  }

  bool isView() const
  {
    return isView(type);
  }

  Type getType() const
  {
    return type;
  }

  virtual std::string getSQLPath() const;

  virtual const std::string &getPath() const;
  const std::string &getKeyPath() const;

  void setPath(const std::string &new_path)
  {
    path= new_path;
  }

  const std::string &getTableName() const
  {
    return table_name;
  }

  void copyToTableMessage(message::Table &message) const;

  friend bool operator<(const Table& left, const Table& right)
  {
    if (left.getKey() < right.getKey())
    {
      return true;
    }

    return false;
  }

  friend bool operator==(const Table& left, const Table& right)
  {
    if (left.getHashValue() == right.getHashValue())
    {
      if (left.getKey() == right.getKey())
        return true;
    }

    return false;
  }

  static uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
  static std::string build_table_filename(const std::string &db, const std::string &table_name, bool is_tmp);
  static std::string build_tmptable_filename();

public:
  bool isValid() const;

  size_t getHashValue() const
  {
    return hash_value;
  }

  const Key &getKey() const
  {
    return key;
  }
};

std::ostream& operator<<(std::ostream& output, const Table&);
std::ostream& operator<<(std::ostream& output, const Table::Key&);
std::size_t hash_value(Table const& b);
std::size_t hash_value(Table::Key const& b);

}
}
# 47 "./drizzled/identifier.h" 2
# 1 "./drizzled/identifier/user.h" 1
# 21 "./drizzled/identifier/user.h"
       




namespace drizzled {
namespace identifier {






class User : public Identifier
{
public:
  __attribute__ ((visibility("default"))) static user::mptr make_shared();

  enum PasswordType
  {
    NONE,
    PLAIN_TEXT,
    MYSQL_HASH
  };

  User() :
    password_type(NONE)
  { }

  User(str_ref user_arg) :
    password_type(NONE),
    _user(to_string(user_arg))
  { }

  virtual std::string getSQLPath() const
  {
    return _user.empty() ? "<no user>" : _user;
  }

  bool hasPassword() const
  {
    return password_type != NONE;
  }

  const std::string& address() const
  {
    return _address;
  }

  void setAddress(const char *newip)
  {
    _address = newip;
  }

  const std::string& username() const
  {
    return _user;
  }

  void setUser(const std::string &newuser)
  {
    _user = newuser;
  }

  PasswordType getPasswordType() const
  {
    return password_type;
  }

  void setPasswordType(PasswordType newpassword_type)
  {
    password_type= newpassword_type;
  }

  const std::string& getPasswordContext() const
  {
    return password_context;
  }

  void setPasswordContext(const char *newpassword_context, size_t size)
  {
    password_context.assign(newpassword_context, size);
  }

private:
  PasswordType password_type;
  std::string _user;
  std::string _address;
  std::string password_context;
};

}
}
# 48 "./drizzled/identifier.h" 2


# 1 "./drizzled/identifier/constants/schema.h" 1
# 21 "./drizzled/identifier/constants/schema.h"
       

namespace drizzled {
namespace identifier {

const Schema& data_dictionary();
const Schema& information_schema();
const Schema& system_schema();

}
}
# 51 "./drizzled/identifier.h" 2
# 1 "./drizzled/identifier/constants/table.h" 1
# 21 "./drizzled/identifier/constants/table.h"
       

namespace drizzled {
namespace identifier {


}
}
# 52 "./drizzled/identifier.h" 2
# 1 "./drizzled/identifier/constants/user.h" 1
# 21 "./drizzled/identifier/constants/user.h"
       

namespace drizzled {
namespace identifier {

const identifier::User& system_user();

}
}
# 52 "./drizzled/identifier.h" 2
# 31 "./drizzled/error.h" 2


namespace drizzled {
# 44 "./drizzled/error.h"
class ErrorMap : boost::noncopyable
{
public:
  typedef std::pair<std::string, std::string> value_type;
  typedef boost::unordered_map<error_t, value_type> ErrorMessageMap;

  ErrorMap();



  void add(error_t error_num, const std::string &error_name, const std::string &message);

  const std::string* find(error_t error_num) const;

  static const ErrorMessageMap& get_error_message_map();
private:
  ErrorMessageMap mapping_;
};

typedef void (*error_handler_func)(error_t my_err,
                                   const char *str,
                                   myf MyFlags);
extern error_handler_func error_handler_hook;



__attribute__ ((visibility("default"))) const char * error_message(error_t err_index);


void add_error_message(error_t error_code, const std::string &error_name,
                       const std::string& message);


namespace error {

void access(const identifier::User&);
void access(const identifier::User&, const identifier::Schema&);
void access(const identifier::User&, const identifier::Table&);

const std::string &verbose_string();
error::priority_t &verbosity();
void check_verbosity(const std::string &arg);

}


__attribute__ ((visibility("default"))) void my_error(const std::string &ref, error_t nr, myf MyFlags= (static_cast<drizzled::myf>(0)));
__attribute__ ((visibility("default"))) void my_error(error_t nr, const Identifier&, myf MyFlags= (static_cast<drizzled::myf>(0)));
__attribute__ ((visibility("default"))) void my_error(error_t nr);
__attribute__ ((visibility("default"))) void my_error(error_t nr, myf MyFlags, ...);
void my_message(error_t my_err, const char *str, myf MyFlags);
void my_printf_error(error_t my_err, const char *format,
                     myf MyFlags, ...)
                     __attribute__((format(printf, 2, 4)));

}
# 30 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/internal/my_sys.h" 1
# 21 "./drizzled/internal/my_sys.h"
       


# 1 "/usr/include/c++/4.8/cstdio" 1 3
# 39 "/usr/include/c++/4.8/cstdio" 3
       
# 40 "/usr/include/c++/4.8/cstdio" 3


# 1 "/usr/include/stdio.h" 1 3 4
# 29 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 74 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 15 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 16 "/usr/include/_G_config.h" 2 3 4




# 1 "/usr/include/wchar.h" 1 3 4
# 21 "/usr/include/_G_config.h" 2 3 4
typedef struct
{
  __off_t __pos;
  __mbstate_t __state;
} _G_fpos_t;
typedef struct
{
  __off64_t __pos;
  __mbstate_t __state;
} _G_fpos64_t;
# 33 "/usr/include/libio.h" 2 3 4
# 50 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdarg.h" 1 3 4
# 51 "/usr/include/libio.h" 2 3 4
# 145 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 155 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 178 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 246 "/usr/include/libio.h" 3 4
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;
# 294 "/usr/include/libio.h" 3 4
  __off64_t _offset;
# 303 "/usr/include/libio.h" 3 4
  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_;
# 339 "/usr/include/libio.h" 3 4
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);
# 435 "/usr/include/libio.h" 3 4
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 ();
# 465 "/usr/include/libio.h" 3 4
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 ();
# 527 "/usr/include/libio.h" 3 4
}
# 75 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
# 108 "/usr/include/stdio.h" 3 4




typedef _G_fpos64_t fpos_t;



typedef _G_fpos64_t fpos64_t;
# 164 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/stdio_lim.h" 1 3 4
# 165 "/usr/include/stdio.h" 2 3 4



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 ();



# 198 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) __asm__ ("" "tmpfile64") __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__));
# 227 "/usr/include/stdio.h" 3 4
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);

# 252 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 262 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);




# 283 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename, const char *__restrict __modes) __asm__ ("" "fopen64")

  __attribute__ ((__warn_unused_result__));
extern FILE *freopen (const char *__restrict __filename, const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")


  __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 ();
# 463 "/usr/include/stdio.h" 3 4








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)));
# 522 "/usr/include/stdio.h" 3 4









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 550 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 561 "/usr/include/stdio.h" 3 4
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);

# 594 "/usr/include/stdio.h" 3 4
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__));
# 638 "/usr/include/stdio.h" 3 4
extern char *gets (char *__s) __attribute__ ((__warn_unused_result__)) __attribute__ ((__deprecated__));


# 649 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
# 665 "/usr/include/stdio.h" 3 4
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);

# 726 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
      FILE *__restrict __stream);
# 737 "/usr/include/stdio.h" 3 4
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);








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);

# 781 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64")

                  ;
extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");








# 806 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64")
                                          ;
extern int fsetpos (FILE *__stream, const fpos_t *__pos) __asm__ ("" "fsetpos64")
                                                          ;








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);






# 1 "/usr/include/i386-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/i386-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];


extern int _sys_nerr;
extern const char *const _sys_errlist[];
# 854 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));




extern int fileno_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
# 873 "/usr/include/stdio.h" 3 4
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 ();
# 934 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/stdio.h" 1 3 4
# 43 "/usr/include/i386-linux-gnu/bits/stdio.h" 3 4
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);
}
# 935 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/stdio2.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/stdio2.h" 3 4
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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__artificial__)) int
vfprintf (FILE *__restrict __stream,
   const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
}


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 __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__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__)) __attribute__ ((__artificial__)) int
vdprintf (int __fd, const char *__restrict __fmt, __gnuc_va_list __ap)
{
  return __vdprintf_chk (__fd, 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 __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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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 ());
}
# 206 "/usr/include/i386-linux-gnu/bits/stdio2.h" 3 4
extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__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__)) __attribute__ ((__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);
}
# 241 "/usr/include/i386-linux-gnu/bits/stdio2.h" 3 4
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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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__)) __attribute__ ((__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);
}
# 938 "/usr/include/stdio.h" 2 3 4





}
# 43 "/usr/include/c++/4.8/cstdio" 2 3
# 93 "/usr/include/c++/4.8/cstdio" 3
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;
}
# 149 "/usr/include/c++/4.8/cstdio" 3
namespace __gnu_cxx
{
# 167 "/usr/include/c++/4.8/cstdio" 3
  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;
}
# 25 "./drizzled/internal/my_sys.h" 2




# 1 "/usr/include/errno.h" 1 3 4
# 30 "./drizzled/internal/my_sys.h" 2



# 1 "./drizzled/internal/my_pthread.h" 1
# 18 "./drizzled/internal/my_pthread.h"
       


# 1 "/usr/include/boost/date_time.hpp" 1 3 4
# 15 "/usr/include/boost/date_time.hpp" 3 4
# 1 "/usr/include/boost/date_time/local_time/local_time.hpp" 1 3 4
# 11 "/usr/include/boost/date_time/local_time/local_time.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time.hpp" 1 3 4
# 24 "/usr/include/boost/date_time/posix_time/posix_time.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 3 4
# 1 "/usr/include/boost/date_time/gregorian/gregorian.hpp" 1 3 4
# 25 "/usr/include/boost/date_time/gregorian/gregorian.hpp" 3 4
# 1 "/usr/include/boost/date_time/gregorian/formatters.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/gregorian/formatters.hpp" 3 4
# 1 "/usr/include/boost/date_time/date_formatting.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/date_formatting.hpp" 3 4
# 1 "/usr/include/boost/date_time/iso_format.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/iso_format.hpp" 3 4
# 1 "/usr/include/boost/date_time/parse_format_base.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/parse_format_base.hpp" 3 4
namespace boost {
namespace date_time {


  enum month_format_spec {month_as_integer, month_as_short_string,
                          month_as_long_string};




  enum ymd_order_spec {ymd_order_iso,
                       ymd_order_dmy,
                       ymd_order_us};


} }
# 13 "/usr/include/boost/date_time/iso_format.hpp" 2 3 4

namespace boost {
namespace date_time {


template<class charT>
class iso_format_base {
public:

  static month_format_spec month_format()
  {
    return month_as_integer;
  }


  static const charT* not_a_date()
  {
    return "not-a-date-time";
  }

  static const charT* pos_infinity()
  {
    return "+infinity";
  }

  static const charT* neg_infinity()
  {
    return "-infinity";
  }


  static charT year_sep_char()
  {
    return 'Y';
  }

  static charT month_sep_char()
  {
    return '-';
  }

  static charT day_sep_char()
  {
    return '-';
  }

  static charT hour_sep_char()
  {
    return ':';
  }

  static charT minute_sep_char()
  {
    return ':';
  }

  static charT second_sep_char()
  {
    return ':';
  }

  static charT period_start_char()
  {
    return 'P';
  }

  static charT time_start_char()
  {
    return 'T';
  }


  static charT week_start_char()
  {
    return 'W';
  }


  static charT period_sep_char()
  {
    return '/';
  }

  static charT time_sep_char()
  {
    return ':';
  }

  static charT fractional_time_sep_char()
  {
    return ',';
  }

  static bool is_component_sep(charT sep)
  {
    switch(sep) {
    case 'H':
    case 'M':
    case 'S':
    case 'W':
    case 'T':
    case 'Y':
    case 'D':return true;
    default:
      return false;
    }
  }

  static bool is_fractional_time_sep(charT sep)
  {
    switch(sep) {
    case ',':
    case '.': return true;
    default: return false;
    }
  }
  static bool is_timezone_sep(charT sep)
  {
    switch(sep) {
    case '+':
    case '-': return true;
    default: return false;
    }
  }
  static charT element_sep_char()
  {
    return '-';
  }

};




template<>
class iso_format_base<wchar_t> {
public:

  static month_format_spec month_format()
  {
    return month_as_integer;
  }


  static const wchar_t* not_a_date()
  {
    return L"not-a-date-time";
  }

  static const wchar_t* pos_infinity()
  {
    return L"+infinity";
  }

  static const wchar_t* neg_infinity()
  {
    return L"-infinity";
  }


  static wchar_t year_sep_char()
  {
    return 'Y';
  }

  static wchar_t month_sep_char()
  {
    return '-';
  }

  static wchar_t day_sep_char()
  {
    return '-';
  }

  static wchar_t hour_sep_char()
  {
    return ':';
  }

  static wchar_t minute_sep_char()
  {
    return ':';
  }

  static wchar_t second_sep_char()
  {
    return ':';
  }

  static wchar_t period_start_char()
  {
    return 'P';
  }

  static wchar_t time_start_char()
  {
    return 'T';
  }


  static wchar_t week_start_char()
  {
    return 'W';
  }


  static wchar_t period_sep_char()
  {
    return '/';
  }

  static wchar_t time_sep_char()
  {
    return ':';
  }

  static wchar_t fractional_time_sep_char()
  {
    return ',';
  }

  static bool is_component_sep(wchar_t sep)
  {
    switch(sep) {
    case 'H':
    case 'M':
    case 'S':
    case 'W':
    case 'T':
    case 'Y':
    case 'D':return true;
    default:
      return false;
    }
  }

  static bool is_fractional_time_sep(wchar_t sep)
  {
    switch(sep) {
    case ',':
    case '.': return true;
    default: return false;
    }
  }
  static bool is_timezone_sep(wchar_t sep)
  {
    switch(sep) {
    case '+':
    case '-': return true;
    default: return false;
    }
  }
  static wchar_t element_sep_char()
  {
    return '-';
  }

};




template<class charT>
class iso_format : public iso_format_base<charT> {
public:

  static bool has_date_sep_chars()
  {
    return false;
  }
};


template<class charT>
class iso_extended_format : public iso_format_base<charT> {
public:

  static bool has_date_sep_chars()
  {
    return true;
  }

};

} }
# 13 "/usr/include/boost/date_time/date_formatting.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/iomanip" 1 3 4
# 36 "/usr/include/c++/4.8/iomanip" 3 4
       
# 37 "/usr/include/c++/4.8/iomanip" 3
# 46 "/usr/include/c++/4.8/iomanip" 3
namespace std __attribute__ ((__visibility__ ("default")))
{





  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
# 62 "/usr/include/c++/4.8/iomanip" 3
  inline _Resetiosflags
  resetiosflags(ios_base::fmtflags __mask)
  { return { __mask }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
    {
      __is.setf(ios_base::fmtflags(0), __f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
    {
      __os.setf(ios_base::fmtflags(0), __f._M_mask);
      return __os;
    }


  struct _Setiosflags { ios_base::fmtflags _M_mask; };
# 92 "/usr/include/c++/4.8/iomanip" 3
  inline _Setiosflags
  setiosflags(ios_base::fmtflags __mask)
  { return { __mask }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
    {
      __is.setf(__f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
    {
      __os.setf(__f._M_mask);
      return __os;
    }


  struct _Setbase { int _M_base; };
# 123 "/usr/include/c++/4.8/iomanip" 3
  inline _Setbase
  setbase(int __base)
  { return { __base }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
    {
      __is.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
    {
      __os.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __os;
    }


  template<typename _CharT>
    struct _Setfill { _CharT _M_c; };
# 160 "/usr/include/c++/4.8/iomanip" 3
  template<typename _CharT>
    inline _Setfill<_CharT>
    setfill(_CharT __c)
    { return { __c }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
    {
      __is.fill(__f._M_c);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
    {
      __os.fill(__f._M_c);
      return __os;
    }


  struct _Setprecision { int _M_n; };
# 191 "/usr/include/c++/4.8/iomanip" 3
  inline _Setprecision
  setprecision(int __n)
  { return { __n }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
    {
      __is.precision(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
    {
      __os.precision(__f._M_n);
      return __os;
    }


  struct _Setw { int _M_n; };
# 221 "/usr/include/c++/4.8/iomanip" 3
  inline _Setw
  setw(int __n)
  { return { __n }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
    {
      __is.width(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
    {
      __os.width(__f._M_n);
      return __os;
    }
# 343 "/usr/include/c++/4.8/iomanip" 3
  extern template ostream& operator<<(ostream&, _Setfill<char>);
  extern template ostream& operator<<(ostream&, _Setiosflags);
  extern template ostream& operator<<(ostream&, _Resetiosflags);
  extern template ostream& operator<<(ostream&, _Setbase);
  extern template ostream& operator<<(ostream&, _Setprecision);
  extern template ostream& operator<<(ostream&, _Setw);
  extern template istream& operator>>(istream&, _Setfill<char>);
  extern template istream& operator>>(istream&, _Setiosflags);
  extern template istream& operator>>(istream&, _Resetiosflags);
  extern template istream& operator>>(istream&, _Setbase);
  extern template istream& operator>>(istream&, _Setprecision);
  extern template istream& operator>>(istream&, _Setw);


  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
  extern template wostream& operator<<(wostream&, _Setiosflags);
  extern template wostream& operator<<(wostream&, _Resetiosflags);
  extern template wostream& operator<<(wostream&, _Setbase);
  extern template wostream& operator<<(wostream&, _Setprecision);
  extern template wostream& operator<<(wostream&, _Setw);
  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
  extern template wistream& operator>>(wistream&, _Setiosflags);
  extern template wistream& operator>>(wistream&, _Resetiosflags);
  extern template wistream& operator>>(wistream&, _Setbase);
  extern template wistream& operator>>(wistream&, _Setprecision);
  extern template wistream& operator>>(wistream&, _Setw);




}
# 17 "/usr/include/boost/date_time/date_formatting.hpp" 2 3 4






namespace boost {
namespace date_time {


  template<class month_type, class format_type, class charT=char>
  class month_formatter
  {
    typedef std::basic_ostream<charT> ostream_type;
  public:





    static ostream_type& format_month(const month_type& month,
                                      ostream_type &os)
    {
      switch (format_type::month_format())
      {
        case month_as_short_string:
        {
          os << month.as_short_string();
          break;
        }
        case month_as_long_string:
        {
          os << month.as_long_string();
          break;
        }
        case month_as_integer:
        {
          os << std::setw(2) << std::setfill(os.widen('0')) << month.as_number();
          break;
        }
        default:
          break;

      }
      return os;
    }
  };



  template<class ymd_type, class format_type, class charT=char>
  class ymd_formatter
  {
  public:
# 80 "/usr/include/boost/date_time/date_formatting.hpp" 3 4
    static std::basic_string<charT> ymd_to_string(ymd_type ymd)
    {
      typedef typename ymd_type::month_type month_type;
      std::basic_ostringstream<charT> ss;



      ss.imbue(std::locale::classic());
      ss << ymd.year;
      ss.imbue(std::locale());

      if (format_type::has_date_sep_chars()) {
        ss << format_type::month_sep_char();
      }

      month_formatter<month_type,format_type,charT>::format_month(ymd.month, ss);
      if (format_type::has_date_sep_chars()) {
        ss << format_type::day_sep_char();
      }
      ss << std::setw(2) << std::setfill(ss.widen('0'))
          << ymd.day;
      return ss.str();
    }
  };



  template<class date_type, class format_type, class charT=char>
  class date_formatter
  {
  public:
    typedef std::basic_string<charT> string_type;

    static string_type date_to_string(date_type d)
    {
      typedef typename date_type::ymd_type ymd_type;
      if (d.is_not_a_date()) {
        return string_type(format_type::not_a_date());
      }
      if (d.is_neg_infinity()) {
        return string_type(format_type::neg_infinity());
      }
      if (d.is_pos_infinity()) {
        return string_type(format_type::pos_infinity());
      }
      ymd_type ymd = d.year_month_day();
      return ymd_formatter<ymd_type, format_type, charT>::ymd_to_string(ymd);
    }
  };


} }
# 18 "/usr/include/boost/date_time/gregorian/formatters.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/date_format_simple.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/date_format_simple.hpp" 3 4
namespace boost {
namespace date_time {


template<class charT>
class simple_format {
public:


  static const charT* not_a_date()
  {
    return "not-a-date-time";
  }

  static const charT* pos_infinity()
  {
    return "+infinity";
  }

  static const charT* neg_infinity()
  {
    return "-infinity";
  }

  static month_format_spec month_format()
  {
    return month_as_short_string;
  }
  static ymd_order_spec date_order()
  {
    return ymd_order_iso;
  }

  static bool has_date_sep_chars()
  {
    return true;
  }

  static charT year_sep_char()
  {
    return '-';
  }

  static charT month_sep_char()
  {
    return '-';
  }

  static charT day_sep_char()
  {
    return '-';
  }

  static charT hour_sep_char()
  {
    return ' ';
  }

  static charT minute_sep_char()
  {
    return ':';
  }

  static charT second_sep_char()
  {
    return ':';
  }

};




template<>
class simple_format<wchar_t> {
public:


  static const wchar_t* not_a_date()
  {
    return L"not-a-date-time";
  }

  static const wchar_t* pos_infinity()
  {
    return L"+infinity";
  }

  static const wchar_t* neg_infinity()
  {
    return L"-infinity";
  }

  static month_format_spec month_format()
  {
    return month_as_short_string;
  }
  static ymd_order_spec date_order()
  {
    return ymd_order_iso;
  }

  static bool has_date_sep_chars()
  {
    return true;
  }

  static wchar_t year_sep_char()
  {
    return '-';
  }

  static wchar_t month_sep_char()
  {
    return '-';
  }

  static wchar_t day_sep_char()
  {
    return '-';
  }

  static wchar_t hour_sep_char()
  {
    return ' ';
  }

  static wchar_t minute_sep_char()
  {
    return ':';
  }

  static wchar_t second_sep_char()
  {
    return ':';
  }

};


} }
# 21 "/usr/include/boost/date_time/gregorian/formatters.hpp" 2 3 4






namespace boost {
namespace gregorian {


  template<class charT>
  inline
  std::basic_string<charT> to_simple_string_type(const date& d) {
    return date_time::date_formatter<date,date_time::simple_format<charT>,charT>::date_to_string(d);
  }



  inline std::string to_simple_string(const date& d) {
    return to_simple_string_type<char>(d);
  }



  template<class charT>
  inline std::basic_string<charT> to_simple_string_type(const date_period& d) {
    typedef std::basic_string<charT> string_type;
    charT b = '[', m = '/', e=']';

    string_type d1(date_time::date_formatter<date,date_time::simple_format<charT>,charT>::date_to_string(d.begin()));
    string_type d2(date_time::date_formatter<date,date_time::simple_format<charT>,charT>::date_to_string(d.last()));
    return string_type(b + d1 + m + d2 + e);
  }



  inline std::string to_simple_string(const date_period& d) {
    return to_simple_string_type<char>(d);
  }


  template<class charT>
  inline std::basic_string<charT> to_iso_string_type(const date_period& d) {
    charT sep = '/';
    std::basic_string<charT> s(date_time::date_formatter<date,date_time::iso_format<charT>,charT>::date_to_string(d.begin()));
    return s + sep + date_time::date_formatter<date,date_time::iso_format<charT>,charT>::date_to_string(d.last());
  }



  inline std::string to_iso_string(const date_period& d) {
    return to_iso_string_type<char>(d);
  }



  template<class charT>
  inline std::basic_string<charT> to_iso_extended_string_type(const date& d) {
    return date_time::date_formatter<date,date_time::iso_extended_format<charT>,charT>::date_to_string(d);
  }



  inline std::string to_iso_extended_string(const date& d) {
    return to_iso_extended_string_type<char>(d);
  }


  template<class charT>
  inline std::basic_string<charT> to_iso_string_type(const date& d) {
    return date_time::date_formatter<date,date_time::iso_format<charT>,charT>::date_to_string(d);
  }



  inline std::string to_iso_string(const date& d) {
    return to_iso_string_type<char>(d);
  }





  template<class charT>
  inline std::basic_string<charT> to_sql_string_type(const date& d)
  {
    date::ymd_type ymd = d.year_month_day();
    std::basic_ostringstream<charT> ss;
    ss << ymd.year << "-"
       << std::setw(2) << std::setfill(ss.widen('0'))
       << ymd.month.as_number()
       << "-"
       << std::setw(2) << std::setfill(ss.widen('0'))
       << ymd.day;
    return ss.str();
  }
  inline std::string to_sql_string(const date& d) {
    return to_sql_string_type<char>(d);
  }






  inline std::wstring to_simple_wstring(const date_period& d) {
    return to_simple_string_type<wchar_t>(d);
  }



  inline std::wstring to_simple_wstring(const date& d) {
    return to_simple_string_type<wchar_t>(d);
  }



  inline std::wstring to_iso_wstring(const date_period& d) {
    return to_iso_string_type<wchar_t>(d);
  }



  inline std::wstring to_iso_extended_wstring(const date& d) {
    return to_iso_extended_string_type<wchar_t>(d);
  }



  inline std::wstring to_iso_wstring(const date& d) {
    return to_iso_string_type<wchar_t>(d);
  }
  inline std::wstring to_sql_wstring(const date& d) {
    return to_sql_string_type<wchar_t>(d);
  }


} }
# 26 "/usr/include/boost/date_time/gregorian/gregorian.hpp" 2 3 4





# 1 "/usr/include/boost/date_time/gregorian/gregorian_io.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/gregorian/gregorian_io.hpp" 3 4
# 1 "/usr/include/boost/io/ios_state.hpp" 1 3 4
# 12 "/usr/include/boost/io/ios_state.hpp" 3 4
# 1 "/usr/include/boost/io_fwd.hpp" 1 3 4
# 15 "/usr/include/boost/io_fwd.hpp" 3 4
namespace boost
{
namespace io
{




class ios_flags_saver;
class ios_precision_saver;
class ios_width_saver;
class ios_base_all_saver;

template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_iostate_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_exception_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_tie_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_rdbuf_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_fill_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_locale_saver;
template < typename Ch, class Tr = ::std::char_traits<Ch> >
    class basic_ios_all_saver;

typedef basic_ios_iostate_saver<char> ios_iostate_saver;
typedef basic_ios_iostate_saver<wchar_t> wios_iostate_saver;
typedef basic_ios_exception_saver<char> ios_exception_saver;
typedef basic_ios_exception_saver<wchar_t> wios_exception_saver;
typedef basic_ios_tie_saver<char> ios_tie_saver;
typedef basic_ios_tie_saver<wchar_t> wios_tie_saver;
typedef basic_ios_rdbuf_saver<char> ios_rdbuf_saver;
typedef basic_ios_rdbuf_saver<wchar_t> wios_rdbuf_saver;
typedef basic_ios_fill_saver<char> ios_fill_saver;
typedef basic_ios_fill_saver<wchar_t> wios_fill_saver;
typedef basic_ios_locale_saver<char> ios_locale_saver;
typedef basic_ios_locale_saver<wchar_t> wios_locale_saver;
typedef basic_ios_all_saver<char> ios_all_saver;
typedef basic_ios_all_saver<wchar_t> wios_all_saver;

class ios_iword_saver;
class ios_pword_saver;
class ios_all_word_saver;


}
}
# 13 "/usr/include/boost/io/ios_state.hpp" 2 3 4
# 24 "/usr/include/boost/io/ios_state.hpp" 3 4
namespace boost
{
namespace io
{




class ios_flags_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef ::std::ios_base::fmtflags aspect_type;

    explicit ios_flags_saver( state_type &s )
        : s_save_( s ), a_save_( s.flags() )
        {}
    ios_flags_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.flags(a) )
        {}
    ~ios_flags_saver()
        { this->restore(); }

    void restore()
        { s_save_.flags( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;

    ios_flags_saver& operator=(const ios_flags_saver&);
};

class ios_precision_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef ::std::streamsize aspect_type;

    explicit ios_precision_saver( state_type &s )
        : s_save_( s ), a_save_( s.precision() )
        {}
    ios_precision_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.precision(a) )
        {}
    ~ios_precision_saver()
        { this->restore(); }

    void restore()
        { s_save_.precision( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;

    ios_precision_saver& operator=(const ios_precision_saver&);
};

class ios_width_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef ::std::streamsize aspect_type;

    explicit ios_width_saver( state_type &s )
        : s_save_( s ), a_save_( s.width() )
        {}
    ios_width_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.width(a) )
        {}
    ~ios_width_saver()
        { this->restore(); }

    void restore()
        { s_save_.width( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    ios_width_saver& operator=(const ios_width_saver&);
};




template < typename Ch, class Tr >
class basic_ios_iostate_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::ios_base::iostate aspect_type;

    explicit basic_ios_iostate_saver( state_type &s )
        : s_save_( s ), a_save_( s.rdstate() )
        {}
    basic_ios_iostate_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.rdstate() )
        { s.clear(a); }
    ~basic_ios_iostate_saver()
        { this->restore(); }

    void restore()
        { s_save_.clear( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_iostate_saver& operator=(const basic_ios_iostate_saver&);
};

template < typename Ch, class Tr >
class basic_ios_exception_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::ios_base::iostate aspect_type;

    explicit basic_ios_exception_saver( state_type &s )
        : s_save_( s ), a_save_( s.exceptions() )
        {}



    basic_ios_exception_saver( state_type &s, aspect_type const &a )

        : s_save_( s ), a_save_( s.exceptions() )
        { s.exceptions(a); }
    ~basic_ios_exception_saver()
        { this->restore(); }

    void restore()
        { s_save_.exceptions( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_exception_saver& operator=(const basic_ios_exception_saver&);
};

template < typename Ch, class Tr >
class basic_ios_tie_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::basic_ostream<Ch, Tr> * aspect_type;

    explicit basic_ios_tie_saver( state_type &s )
        : s_save_( s ), a_save_( s.tie() )
        {}
    basic_ios_tie_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.tie(a) )
        {}
    ~basic_ios_tie_saver()
        { this->restore(); }

    void restore()
        { s_save_.tie( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_tie_saver& operator=(const basic_ios_tie_saver&);
};

template < typename Ch, class Tr >
class basic_ios_rdbuf_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::basic_streambuf<Ch, Tr> * aspect_type;

    explicit basic_ios_rdbuf_saver( state_type &s )
        : s_save_( s ), a_save_( s.rdbuf() )
        {}
    basic_ios_rdbuf_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.rdbuf(a) )
        {}
    ~basic_ios_rdbuf_saver()
        { this->restore(); }

    void restore()
        { s_save_.rdbuf( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_rdbuf_saver& operator=(const basic_ios_rdbuf_saver&);
};

template < typename Ch, class Tr >
class basic_ios_fill_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef typename state_type::char_type aspect_type;

    explicit basic_ios_fill_saver( state_type &s )
        : s_save_( s ), a_save_( s.fill() )
        {}
    basic_ios_fill_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.fill(a) )
        {}
    ~basic_ios_fill_saver()
        { this->restore(); }

    void restore()
        { s_save_.fill( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_fill_saver& operator=(const basic_ios_fill_saver&);
};


template < typename Ch, class Tr >
class basic_ios_locale_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;
    typedef ::std::locale aspect_type;

    explicit basic_ios_locale_saver( state_type &s )
        : s_save_( s ), a_save_( s.getloc() )
        {}
    basic_ios_locale_saver( state_type &s, aspect_type const &a )
        : s_save_( s ), a_save_( s.imbue(a) )
        {}
    ~basic_ios_locale_saver()
        { this->restore(); }

    void restore()
        { s_save_.imbue( a_save_ ); }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    basic_ios_locale_saver& operator=(const basic_ios_locale_saver&);
};





class ios_iword_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef int index_type;
    typedef long aspect_type;

    explicit ios_iword_saver( state_type &s, index_type i )
        : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
        {}
    ios_iword_saver( state_type &s, index_type i, aspect_type const &a )
        : s_save_( s ), a_save_( s.iword(i) ), i_save_( i )
        { s.iword(i) = a; }
    ~ios_iword_saver()
        { this->restore(); }

    void restore()
        { s_save_.iword( i_save_ ) = a_save_; }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    index_type const i_save_;

    ios_iword_saver& operator=(const ios_iword_saver&);
};

class ios_pword_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef int index_type;
    typedef void * aspect_type;

    explicit ios_pword_saver( state_type &s, index_type i )
        : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
        {}
    ios_pword_saver( state_type &s, index_type i, aspect_type const &a )
        : s_save_( s ), a_save_( s.pword(i) ), i_save_( i )
        { s.pword(i) = a; }
    ~ios_pword_saver()
        { this->restore(); }

    void restore()
        { s_save_.pword( i_save_ ) = a_save_; }

private:
    state_type & s_save_;
    aspect_type const a_save_;
    index_type const i_save_;

    ios_pword_saver operator=(const ios_pword_saver&);
};




class ios_base_all_saver
{
public:
    typedef ::std::ios_base state_type;

    explicit ios_base_all_saver( state_type &s )
        : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
        , a3_save_( s.width() )
        {}

    ~ios_base_all_saver()
        { this->restore(); }

    void restore()
    {
        s_save_.width( a3_save_ );
        s_save_.precision( a2_save_ );
        s_save_.flags( a1_save_ );
    }

private:
    state_type & s_save_;
    state_type::fmtflags const a1_save_;
    ::std::streamsize const a2_save_;
    ::std::streamsize const a3_save_;

    ios_base_all_saver& operator=(const ios_base_all_saver&);
};

template < typename Ch, class Tr >
class basic_ios_all_saver
{
public:
    typedef ::std::basic_ios<Ch, Tr> state_type;

    explicit basic_ios_all_saver( state_type &s )
        : s_save_( s ), a1_save_( s.flags() ), a2_save_( s.precision() )
        , a3_save_( s.width() ), a4_save_( s.rdstate() )
        , a5_save_( s.exceptions() ), a6_save_( s.tie() )
        , a7_save_( s.rdbuf() ), a8_save_( s.fill() )

        , a9_save_( s.getloc() )

        {}

    ~basic_ios_all_saver()
        { this->restore(); }

    void restore()
    {

        s_save_.imbue( a9_save_ );

        s_save_.fill( a8_save_ );
        s_save_.rdbuf( a7_save_ );
        s_save_.tie( a6_save_ );
        s_save_.exceptions( a5_save_ );
        s_save_.clear( a4_save_ );
        s_save_.width( a3_save_ );
        s_save_.precision( a2_save_ );
        s_save_.flags( a1_save_ );
    }

private:
    state_type & s_save_;
    typename state_type::fmtflags const a1_save_;
    ::std::streamsize const a2_save_;
    ::std::streamsize const a3_save_;
    typename state_type::iostate const a4_save_;
    typename state_type::iostate const a5_save_;
    ::std::basic_ostream<Ch, Tr> * const a6_save_;
    ::std::basic_streambuf<Ch, Tr> * const a7_save_;
    typename state_type::char_type const a8_save_;

    ::std::locale const a9_save_;


    basic_ios_all_saver& operator=(const basic_ios_all_saver&);
};

class ios_all_word_saver
{
public:
    typedef ::std::ios_base state_type;
    typedef int index_type;

    ios_all_word_saver( state_type &s, index_type i )
        : s_save_( s ), i_save_( i ), a1_save_( s.iword(i) )
        , a2_save_( s.pword(i) )
        {}

    ~ios_all_word_saver()
        { this->restore(); }

    void restore()
    {
        s_save_.pword( i_save_ ) = a2_save_;
        s_save_.iword( i_save_ ) = a1_save_;
    }

private:
    state_type & s_save_;
    index_type const i_save_;
    long const a1_save_;
    void * const a2_save_;

    ios_all_word_saver& operator=(const ios_all_word_saver&);
};


}
}
# 16 "/usr/include/boost/date_time/gregorian/gregorian_io.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_facet.hpp" 1 3 4
# 21 "/usr/include/boost/date_time/date_facet.hpp" 3 4
# 1 "/usr/include/boost/date_time/special_values_formatter.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/special_values_formatter.hpp" 3 4
namespace boost { namespace date_time {
# 29 "/usr/include/boost/date_time/special_values_formatter.hpp" 3 4
  template <class CharT, class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
  class special_values_formatter
  {
  public:
    typedef std::basic_string<CharT> string_type;
    typedef CharT char_type;
    typedef std::vector<string_type> collection_type;
    static const char_type default_special_value_names[3][17];




    special_values_formatter()
    {
      std::copy(&default_special_value_names[0],
                &default_special_value_names[3],
                std::back_inserter(m_special_value_names));
    }
# 58 "/usr/include/boost/date_time/special_values_formatter.hpp" 3 4
    special_values_formatter(const char_type* const* begin, const char_type* const* end)
    {
      std::copy(begin, end, std::back_inserter(m_special_value_names));
    }
    special_values_formatter(typename collection_type::iterator beg, typename collection_type::iterator end)
    {
      std::copy(beg, end, std::back_inserter(m_special_value_names));
    }

    OutItrT put_special(OutItrT next,
                        const boost::date_time::special_values& value) const
    {

      unsigned int index = value;
      if (index < m_special_value_names.size()) {
        std::copy(m_special_value_names[index].begin(),
                  m_special_value_names[index].end(),
                  next);
      }
      return next;
    }
  protected:
    collection_type m_special_value_names;
  };






  template <class CharT, class OutItrT>
  const typename special_values_formatter<CharT, OutItrT>::char_type special_values_formatter<CharT, OutItrT>::default_special_value_names[3][17] = {
    {'n','o','t','-','a','-','d','a','t','e','-','t','i','m','e'},
    {'-','i','n','f','i','n','i','t','y'},
    {'+','i','n','f','i','n','i','t','y'} };

 } }
# 22 "/usr/include/boost/date_time/date_facet.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/period_formatter.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/period_formatter.hpp" 3 4
namespace boost { namespace date_time {
# 36 "/usr/include/boost/date_time/period_formatter.hpp" 3 4
  template <class CharT, class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
  class period_formatter {
  public:
    typedef std::basic_string<CharT> string_type;
    typedef CharT char_type;
    typedef typename std::basic_string<char_type>::const_iterator const_itr_type;
    typedef std::vector<std::basic_string<CharT> > collection_type;

    static const char_type default_period_separator[2];
    static const char_type default_period_start_delimeter[2];
    static const char_type default_period_open_range_end_delimeter[2];
    static const char_type default_period_closed_range_end_delimeter[2];

    enum range_display_options { AS_OPEN_RANGE, AS_CLOSED_RANGE };


    period_formatter(range_display_options range_option_in = AS_CLOSED_RANGE,
                     const char_type* const period_separator = default_period_separator,
                     const char_type* const period_start_delimeter = default_period_start_delimeter,
                     const char_type* const period_open_range_end_delimeter = default_period_open_range_end_delimeter,
                     const char_type* const period_closed_range_end_delimeter = default_period_closed_range_end_delimeter) :
      m_range_option(range_option_in),
      m_period_separator(period_separator),
      m_period_start_delimeter(period_start_delimeter),
      m_open_range_end_delimeter(period_open_range_end_delimeter),
      m_closed_range_end_delimeter(period_closed_range_end_delimeter)
    {}


    OutItrT put_period_separator(OutItrT& oitr) const
    {
      const_itr_type ci = m_period_separator.begin();
      while (ci != m_period_separator.end()) {
        *oitr = *ci;
        ci++;
      }
      return oitr;
    }


    OutItrT put_period_start_delimeter(OutItrT& oitr) const
    {
      const_itr_type ci = m_period_start_delimeter.begin();
      while (ci != m_period_start_delimeter.end()) {
        *oitr = *ci;
        ci++;
      }
      return oitr;
    }


    OutItrT put_period_end_delimeter(OutItrT& oitr) const
    {

      const_itr_type ci, end;
      if (m_range_option == AS_OPEN_RANGE) {
        ci = m_open_range_end_delimeter.begin();
        end = m_open_range_end_delimeter.end();
      }
      else {
        ci = m_closed_range_end_delimeter.begin();
        end = m_closed_range_end_delimeter.end();
      }
      while (ci != end) {
        *oitr = *ci;
        ci++;
      }
      return oitr;
    }

    range_display_options range_option() const
    {
      return m_range_option;
    }


    void
    range_option(range_display_options option) const
    {
      m_range_option = option;
    }
    void delimiter_strings(const string_type& ,
                           const string_type& ,
                           const string_type& ,
                           const string_type& )
    {
      m_period_separator;
      m_period_start_delimeter;
      m_open_range_end_delimeter;
      m_closed_range_end_delimeter;
    }
# 150 "/usr/include/boost/date_time/period_formatter.hpp" 3 4
    template<class period_type, class facet_type>
    OutItrT put_period(OutItrT next,
                       std::ios_base& a_ios,
                       char_type a_fill,
                       const period_type& p,
                       const facet_type& facet) const {
      put_period_start_delimeter(next);
      next = facet.put(next, a_ios, a_fill, p.begin());
      put_period_separator(next);
      if (m_range_option == AS_CLOSED_RANGE) {
        facet.put(next, a_ios, a_fill, p.last());
      }
      else {
        facet.put(next, a_ios, a_fill, p.end());
      }
      put_period_end_delimeter(next);
      return next;
    }


  private:
    range_display_options m_range_option;
    string_type m_period_separator;
    string_type m_period_start_delimeter;
    string_type m_open_range_end_delimeter;
    string_type m_closed_range_end_delimeter;
  };

  template <class CharT, class OutItrT>
  const typename period_formatter<CharT, OutItrT>::char_type
  period_formatter<CharT, OutItrT>::default_period_separator[2] = {'/'};

  template <class CharT, class OutItrT>
  const typename period_formatter<CharT, OutItrT>::char_type
  period_formatter<CharT, OutItrT>::default_period_start_delimeter[2] = {'['};

  template <class CharT, class OutItrT>
  const typename period_formatter<CharT, OutItrT>::char_type
  period_formatter<CharT, OutItrT>::default_period_open_range_end_delimeter[2] = {')'};

  template <class CharT, class OutItrT>
  const typename period_formatter<CharT, OutItrT>::char_type
  period_formatter<CharT, OutItrT>::default_period_closed_range_end_delimeter[2] = {']'};

 } }
# 23 "/usr/include/boost/date_time/date_facet.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/period_parser.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/period_parser.hpp" 3 4
# 1 "/usr/include/boost/date_time/string_parse_tree.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/string_parse_tree.hpp" 3 4
# 1 "/usr/include/boost/lexical_cast.hpp" 1 3 4
# 29 "/usr/include/boost/lexical_cast.hpp" 3 4
# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 30 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 31 "/usr/include/boost/lexical_cast.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 33 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cstdio" 1 3 4
# 39 "/usr/include/c++/4.8/cstdio" 3 4
       
# 40 "/usr/include/c++/4.8/cstdio" 3
# 34 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 42 "/usr/include/boost/lexical_cast.hpp" 3 4
# 1 "/usr/include/boost/detail/lcast_precision.hpp" 1 3 4
# 11 "/usr/include/boost/detail/lcast_precision.hpp" 3 4
# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 12 "/usr/include/boost/detail/lcast_precision.hpp" 2 3 4
# 36 "/usr/include/boost/detail/lcast_precision.hpp" 3 4
namespace boost { namespace detail {

class lcast_abstract_stub {};





template<class T>
struct lcast_precision
{



    typedef typename boost::mpl::if_<
        boost::is_abstract<T>
      , std::numeric_limits<lcast_abstract_stub>
      , std::numeric_limits<T>
      >::type limits;


    static const bool use_default_precision = !limits::is_specialized || limits::is_exact

         ;

    static const bool is_specialized_bin = !use_default_precision && limits::radix == 2 && limits::digits > 0


         ;

    static const bool is_specialized_dec = !use_default_precision && limits::radix == 10 && limits::digits10 > 0


         ;

    static const std::streamsize streamsize_max = boost::integer_traits<std::streamsize>::const_max

         ;

    static const unsigned int precision_dec = limits::digits10 + 1U;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_specialized_dec || precision_dec <= streamsize_max + 0UL) == 0 ? false : true) >)> boost_static_assert_typedef_79

         ;

    static const unsigned long precision_bin = 2UL + limits::digits * 30103UL / 100000UL

         ;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_specialized_bin || (limits::digits + 0UL < (2147483647L * 2UL + 1UL) / 30103UL && precision_bin > limits::digits10 + 0UL && precision_bin <= streamsize_max + 0UL)) == 0 ? false : true) >)> boost_static_assert_typedef_89



         ;

    static const std::streamsize value = is_specialized_bin ? precision_bin : is_specialized_dec ? precision_dec : 6


         ;
};


template<class T>
inline std::streamsize lcast_get_precision(T* = 0)
{

    return lcast_precision<T>::value;
# 165 "/usr/include/boost/detail/lcast_precision.hpp" 3 4
}

template<class T>
inline void lcast_set_precision(std::ios_base& stream, T*)
{
    stream.precision(lcast_get_precision<T>());
}

template<class Source, class Target>
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
{
    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
    stream.precision(s > t ? s : t);
}

}}
# 43 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 72 "/usr/include/boost/lexical_cast.hpp" 3 4
namespace boost
{

    class __attribute__((visibility("default"))) bad_lexical_cast :




        public std::bad_cast







    {
    public:
        bad_lexical_cast() :

          source(&typeid(void)), target(&typeid(void))



        {
        }

        bad_lexical_cast(
            const std::type_info &source_type_arg,
            const std::type_info &target_type_arg) :
            source(&source_type_arg), target(&target_type_arg)
        {
        }

        const std::type_info &source_type() const
        {
            return *source;
        }
        const std::type_info &target_type() const
        {
            return *target;
        }




        virtual const char *what() const throw()

        {
            return "bad lexical cast: "
                   "source type value could not be interpreted as target";
        }




        virtual ~bad_lexical_cast() throw()

        {}
    private:
        const std::type_info *source;
        const std::type_info *target;
    };

    namespace detail
    {
        template <typename TargetChar, typename SourceChar>
        struct widest_char
        {
            typedef typename boost::mpl::if_c<
                (sizeof(TargetChar) > sizeof(SourceChar))
                , TargetChar
                , SourceChar >::type type;
        };
    }
}



# 1 "/usr/include/c++/4.8/cmath" 1 3 4
# 39 "/usr/include/c++/4.8/cmath" 3 4
       
# 40 "/usr/include/c++/4.8/cmath" 3
# 152 "/usr/include/boost/lexical_cast.hpp" 2 3 4






# 1 "/usr/include/boost/array.hpp" 1 3 4
# 42 "/usr/include/boost/array.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 43 "/usr/include/boost/array.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 45 "/usr/include/boost/array.hpp" 2 3 4





# 1 "/usr/include/boost/functional/hash_fwd.hpp" 1 3 4
# 51 "/usr/include/boost/array.hpp" 2 3 4






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;
# 104 "/usr/include/boost/array.hpp" 3 4
        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)
        {
            ((i < N) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("i < N", "out of range", __PRETTY_FUNCTION__, "/usr/include/boost/array.hpp", 123));
            return elems[i];
        }

        const_reference operator[](size_type i) const
        {
            ((i < N) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("i < N", "out of range", __PRETTY_FUNCTION__, "/usr/include/boost/array.hpp", 129));
            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;
# 245 "/usr/include/boost/array.hpp" 3 4
        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);
    }
# 400 "/usr/include/boost/array.hpp" 3 4
    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;
    }
# 433 "/usr/include/boost/array.hpp" 3 4
    template<class T, std::size_t N>
    std::size_t hash_value(const array<T,N>& arr)
    {
        return boost::hash_range(arr.begin(), arr.end());
    }

}
# 159 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/cast.hpp" 1 3 4
# 33 "/usr/include/boost/numeric/conversion/cast.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/converter.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/converter.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
# 1 "/usr/include/boost/mpl/equal_to.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/equal_to.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/numeric_cast.hpp" 1 3 4
# 30 "/usr/include/boost/mpl/numeric_cast.hpp" 3 4
namespace boost { namespace mpl {



template< typename SourceTag, typename TargetTag > struct numeric_cast
{
    template< typename N > struct apply;
};

}}
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/tag.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_tag.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_tag.hpp" 3 4
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; };
}}}
# 20 "/usr/include/boost/mpl/tag.hpp" 2 3 4


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
{
# 48 "/usr/include/boost/mpl/tag.hpp" 3 4
};

}}
# 25 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/forwarding.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4

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
            >
    {
# 46 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
    };
};

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
            >
    {
# 72 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
    };
};

}}}
# 26 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
# 62 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
}}}
# 18 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 2 3 4




namespace boost { namespace mpl { namespace aux {
# 55 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
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 };
};

}}}
# 30 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 3 4
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 ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/equal_to.hpp" 2 3 4
# 18 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 2 3 4





namespace boost { namespace numeric { namespace convdetail
{
   template< class T1, class T2>
   struct equal_to
   {


       enum { x = ( T1::value == T2::value ) };

       static const bool value = x;

       typedef mpl::bool_<value> type;
# 48 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
   };
# 59 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
  template<class Value,
           class Case0Val,
           class Case1Val,
           class Case2Val,
           class Case0Type,
           class Case1Type,
           class Case2Type,
           class DefaultType
          >
  struct ct_switch4
  {
    typedef mpl::identity<Case0Type> Case0TypeQ ;
    typedef mpl::identity<Case1Type> Case1TypeQ ;

    typedef equal_to<Value,Case0Val> is_case0 ;
    typedef equal_to<Value,Case1Val> is_case1 ;
    typedef equal_to<Value,Case2Val> is_case2 ;

    typedef mpl::if_<is_case2,Case2Type,DefaultType> choose_2_3Q ;
    typedef mpl::eval_if<is_case1,Case1TypeQ,choose_2_3Q> choose_1_2_3Q ;

    typedef typename
      mpl::eval_if<is_case0,Case0TypeQ,choose_1_2_3Q>::type
        type ;
  } ;
# 97 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
  template<class expr0, class expr1, class TT, class TF, class FT, class FF>
  struct for_both
  {
    typedef mpl::identity<TF> TF_Q ;
    typedef mpl::identity<TT> TT_Q ;

    typedef typename mpl::not_<expr0>::type not_expr0 ;
    typedef typename mpl::not_<expr1>::type not_expr1 ;

    typedef typename mpl::and_<expr0,expr1>::type caseTT ;
    typedef typename mpl::and_<expr0,not_expr1>::type caseTF ;
    typedef typename mpl::and_<not_expr0,expr1>::type caseFT ;

    typedef mpl::if_<caseFT,FT,FF> choose_FT_FF_Q ;
    typedef mpl::eval_if<caseTF,TF_Q,choose_FT_FF_Q> choose_TF_FT_FF_Q ;

    typedef typename mpl::eval_if<caseTT,TT_Q,choose_TF_FT_FF_Q>::type type ;
  } ;

} } }
# 18 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 1 3 4
# 16 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 3 4
namespace boost { namespace numeric
{
  enum int_float_mixture_enum
  {
     integral_to_integral
    ,integral_to_float
    ,float_to_integral
    ,float_to_float
  } ;

} }
# 17 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<int_float_mixture_enum, integral_to_integral> int2int_c ;
  typedef mpl::integral_c<int_float_mixture_enum, integral_to_float> int2float_c ;
  typedef mpl::integral_c<int_float_mixture_enum, float_to_integral> float2int_c ;
  typedef mpl::integral_c<int_float_mixture_enum, float_to_float> float2float_c ;







  template<class T,class S>
  struct get_int_float_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_integer > S_int ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_integer > T_int ;

    typedef typename
      for_both<S_int, T_int, int2int_c, int2float_c, float2int_c, float2float_c>::type
        type ;
  } ;
# 55 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
  template<class IntFloatMixture, class Int2Int, class Int2Float, class Float2Int, class Float2Float>
  struct for_int_float_mixture
  {
    typedef typename
      ct_switch4<IntFloatMixture
                 ,int2int_c, int2float_c, float2int_c
                 ,Int2Int , Int2Float , Float2Int , Float2Float
                >::type
        type ;
  } ;

} } }
# 19 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 1 3 4
# 16 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/sign_mixture_enum.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/sign_mixture_enum.hpp" 3 4
namespace boost { namespace numeric
{
  enum sign_mixture_enum
  {
     unsigned_to_unsigned
    ,signed_to_signed
    ,signed_to_unsigned
    ,unsigned_to_signed
  } ;

} }
# 17 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
  typedef mpl::integral_c<sign_mixture_enum, signed_to_signed> sig2sig_c ;
  typedef mpl::integral_c<sign_mixture_enum, signed_to_unsigned> sig2unsig_c ;
  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_signed> unsig2sig_c ;







  template<class T,class S>
  struct get_sign_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_signed > S_signed ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_signed > T_signed ;

    typedef typename
      for_both<S_signed, T_signed, sig2sig_c, sig2unsig_c, unsig2sig_c, unsig2unsig_c>::type
        type ;
  } ;
# 55 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
  template<class SignMixture, class Sig2Sig, class Sig2Unsig, class Unsig2Sig, class Unsig2Unsig>
  struct for_sign_mixture
  {
    typedef typename
      ct_switch4<SignMixture
                 , sig2sig_c, sig2unsig_c, unsig2sig_c
                 , Sig2Sig , Sig2Unsig , Unsig2Sig , Unsig2Unsig
                >::type
        type ;
  } ;

} } }
# 20 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 1 3 4
# 15 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 3 4
namespace boost { namespace numeric
{
  enum udt_builtin_mixture_enum
  {
     builtin_to_builtin
    ,builtin_to_udt
    ,udt_to_builtin
    ,udt_to_udt
  } ;

} }
# 16 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_udt> builtin2udt_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_builtin> udt2builtin_c ;
  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_udt> udt2udt_c ;
# 37 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
  template<class UdtMixture, class BuiltIn2BuiltIn, class BuiltIn2Udt, class Udt2BuiltIn, class Udt2Udt>
  struct for_udt_builtin_mixture
  {
    typedef typename
      ct_switch4<UdtMixture
                 , builtin2builtin_c, builtin2udt_c, udt2builtin_c
                 , BuiltIn2BuiltIn , BuiltIn2Udt , Udt2BuiltIn , Udt2Udt
                >::type
        type ;
  } ;







  template<class T,class S>
  struct get_udt_builtin_mixture
  {
    typedef is_arithmetic<S> S_builtin ;
    typedef is_arithmetic<T> T_builtin ;

    typedef typename
      for_both<S_builtin, T_builtin, builtin2builtin_c, builtin2udt_c, udt2builtin_c, udt2udt_c>::type
        type ;
  } ;

} } }
# 21 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
# 1 "/usr/include/boost/mpl/multiplies.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/multiplies.hpp" 3 4
# 1 "/usr/include/boost/mpl/times.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/times.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/times.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/times.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct times_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct times_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct times_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct times_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct times_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct times
    : times< times< times< times< N1,N2 >, N3>, N4>, N5>
{
   




};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct times< N1,N2,N3,N4,na >

    : times< times< times< N1,N2 >, N3>, N4>
{
   




};

template<
      typename N1, typename N2, typename N3
    >
struct times< N1,N2,N3,na,na >

    : times< times< N1,N2 >, N3>
{
   




};

template<
      typename N1, typename N2
    >
struct times< N1,N2,na,na,na >
    : times_impl<
          typename times_tag<N1>::type
        , typename times_tag<N2>::type
        >::template apply< N1,N2 >::type
{
   





};

template<> struct times< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : times< T1 , T2 > { }; }; template< typename Tag > struct lambda< times< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef times< na , na > result_; typedef times< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< times< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< times< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct times_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
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/times.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/multiplies.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/preprocessor/default_params.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/multiplies.hpp" 2 3 4





namespace boost { namespace mpl {







template<
      typename N1 = na , typename N2 = na , typename N3 = na , typename N4 = na , typename N5 = na
    >
struct multiplies
    : times< N1 , N2 , N3 , N4 , N5 >
{
   




};

template<> struct multiplies< na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct apply : multiplies< T1 , T2 , T3 , T4 , T5 > { }; }; template< typename Tag > struct lambda< multiplies< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef multiplies< na , na , na , na , na > result_; typedef multiplies< na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< multiplies< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< multiplies< na , na , na , na , na > > : int_<-1> { }; }



}}
# 18 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/less.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/less.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 3 4
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 ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/less.hpp" 2 3 4
# 19 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
# 28 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
namespace boost { namespace numeric { namespace convdetail
{





    template<class T,class S>
    struct subranged_Sig2Unsig
    {


      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_Unsig2Sig
    {
# 62 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;


       typedef typename T_digits::next u_T_digits ;

       typedef mpl::int_<2> Two ;

       typedef typename mpl::multiplies<S_digits,Two>::type S_digits_times_2 ;

       typedef typename mpl::less<u_T_digits,S_digits_times_2>::type type ;
    } ;


    template<class T,class S>
    struct subranged_SameSign
    {


       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;

       typedef typename mpl::less<T_digits,S_digits>::type type ;
    } ;


    template<class T,class S>
    struct subranged_Int2Float
    {
      typedef mpl::false_ type ;
    } ;


    template<class T,class S>
    struct subranged_Float2Int
    {
      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_Float2Float
    {



      typedef mpl::int_< ::std::numeric_limits<S>::digits > S_mantisa ;
      typedef mpl::int_< ::std::numeric_limits<T>::digits > T_mantisa ;

      typedef mpl::int_< ::std::numeric_limits<S>::max_exponent > S_exponent ;
      typedef mpl::int_< ::std::numeric_limits<T>::max_exponent > T_exponent ;

      typedef typename mpl::less<T_exponent,S_exponent>::type T_smaller_exponent ;

      typedef typename mpl::equal_to<T_exponent,S_exponent>::type equal_exponents ;

      typedef mpl::less<T_mantisa,S_mantisa> T_smaller_mantisa ;

      typedef mpl::eval_if<equal_exponents,T_smaller_mantisa,mpl::false_> not_bigger_exponent_case ;

      typedef typename
        mpl::eval_if<T_smaller_exponent,mpl::true_,not_bigger_exponent_case>::type
          type ;
    } ;


    template<class T,class S>
    struct subranged_Udt2BuiltIn
    {
      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_BuiltIn2Udt
    {
      typedef mpl::false_ type ;
    } ;


    template<class T,class S>
    struct subranged_Udt2Udt
    {
      typedef mpl::false_ type ;
    } ;





    template<class T,class S>
    struct get_subranged_Int2Int
    {
      typedef subranged_SameSign<T,S> Sig2Sig ;
      typedef subranged_Sig2Unsig<T,S> Sig2Unsig ;
      typedef subranged_Unsig2Sig<T,S> Unsig2Sig ;
      typedef Sig2Sig Unsig2Unsig ;

      typedef typename get_sign_mixture<T,S>::type sign_mixture ;

      typedef typename
        for_sign_mixture<sign_mixture, Sig2Sig, Sig2Unsig, Unsig2Sig, Unsig2Unsig>::type
           type ;
    } ;

    template<class T,class S>
    struct get_subranged_BuiltIn2BuiltIn
    {
      typedef get_subranged_Int2Int<T,S> Int2IntQ ;

      typedef subranged_Int2Float <T,S> Int2Float ;
      typedef subranged_Float2Int <T,S> Float2Int ;
      typedef subranged_Float2Float<T,S> Float2Float ;

      typedef mpl::identity<Int2Float > Int2FloatQ ;
      typedef mpl::identity<Float2Int > Float2IntQ ;
      typedef mpl::identity<Float2Float> Float2FloatQ ;

      typedef typename get_int_float_mixture<T,S>::type int_float_mixture ;

      typedef for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ> for_ ;

      typedef typename for_::type selected ;

      typedef typename selected::type type ;
    } ;

    template<class T,class S>
    struct get_subranged
    {
      typedef get_subranged_BuiltIn2BuiltIn<T,S> BuiltIn2BuiltInQ ;

      typedef subranged_BuiltIn2Udt<T,S> BuiltIn2Udt ;
      typedef subranged_Udt2BuiltIn<T,S> Udt2BuiltIn ;
      typedef subranged_Udt2Udt<T,S> Udt2Udt ;

      typedef mpl::identity<BuiltIn2Udt> BuiltIn2UdtQ ;
      typedef mpl::identity<Udt2BuiltIn> Udt2BuiltInQ ;
      typedef mpl::identity<Udt2Udt > Udt2UdtQ ;

      typedef typename get_udt_builtin_mixture<T,S>::type udt_builtin_mixture ;

      typedef typename
        for_udt_builtin_mixture<udt_builtin_mixture, BuiltIn2BuiltInQ, BuiltIn2UdtQ, Udt2BuiltInQ, Udt2UdtQ>::type
          selected ;

      typedef typename selected::type selected2 ;

      typedef typename selected2::type type ;
    } ;





  template<class T, class S>
  struct get_is_subranged
  {
    typedef get_subranged<T,S> non_trivial_case ;
    typedef mpl::identity<mpl::false_> trivial_case ;

    typedef is_same<T,S> is_trivial ;

    typedef typename mpl::if_<is_trivial,trivial_case,non_trivial_case>::type selected ;

    typedef typename selected::type type ;
  } ;

} } }
# 22 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4

namespace boost { namespace numeric { namespace convdetail
{





  template<class T,class S>
  struct non_trivial_traits_impl
  {
    typedef typename get_int_float_mixture <T,S>::type int_float_mixture ;
    typedef typename get_sign_mixture <T,S>::type sign_mixture ;
    typedef typename get_udt_builtin_mixture <T,S>::type udt_builtin_mixture ;

    typedef typename get_is_subranged<T,S>::type subranged ;

    typedef mpl::false_ trivial ;

    typedef T target_type ;
    typedef S source_type ;
    typedef T result_type ;

    typedef typename mpl::if_< is_arithmetic<S>, S, S const&>::type argument_type ;

    typedef typename mpl::if_<subranged,S,T>::type supertype ;
    typedef typename mpl::if_<subranged,T,S>::type subtype ;
  } ;






  template<class N>
  struct trivial_traits_impl
  {
    typedef typename get_int_float_mixture <N,N>::type int_float_mixture ;
    typedef typename get_sign_mixture <N,N>::type sign_mixture ;
    typedef typename get_udt_builtin_mixture<N,N>::type udt_builtin_mixture ;

    typedef mpl::false_ subranged ;
    typedef mpl::true_ trivial ;

    typedef N target_type ;
    typedef N source_type ;
    typedef N const& result_type ;
    typedef N const& argument_type ;

    typedef N supertype ;
    typedef N subtype ;

  } ;




  template<class T, class S>
  struct get_conversion_traits
  {
    typedef typename remove_cv<T>::type target_type ;
    typedef typename remove_cv<S>::type source_type ;

    typedef typename is_same<target_type,source_type>::type is_trivial ;

    typedef trivial_traits_impl <target_type> trivial_imp ;
    typedef non_trivial_traits_impl<target_type,source_type> non_trivial_imp ;

    typedef typename mpl::if_<is_trivial,trivial_imp,non_trivial_imp>::type type ;
  } ;

} } }
# 14 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 2 3 4



namespace boost { namespace numeric
{

template<class T, class S>
struct conversion_traits
    : convdetail::get_conversion_traits<T,S>::type
{







} ;

} }
# 14 "/usr/include/boost/numeric/conversion/converter.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/converter_policies.hpp" 1 3 4
# 25 "/usr/include/boost/numeric/conversion/converter_policies.hpp" 3 4
namespace boost { namespace numeric
{

template<class S>
struct Trunc
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::floor ;
    using std::ceil ;


    return s < static_cast<S>(0) ? ceil(s) : floor(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_zero> round_style ;
} ;



template<class S>
struct Floor
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::floor ;


    return floor(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_neg_infinity> round_style ;
} ;

template<class S>
struct Ceil
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::ceil ;


    return ceil(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_infinity> round_style ;
} ;

template<class S>
struct RoundEven
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {



    using std::floor ;
    using std::ceil ;



    S prev = floor(s);
    S next = ceil(s);

    S rt = (s - prev) - (next - s);

    S const zero(0.0);
    S const two(2.0);

    if ( rt < zero )
      return prev;
    else if ( rt > zero )
      return next;
    else
    {
      bool is_prev_even = two * floor(prev / two) == prev ;
      return ( is_prev_even ? prev : next ) ;
    }
  }

  typedef mpl::integral_c< std::float_round_style, std::round_to_nearest> round_style ;
} ;


enum range_check_result
{
  cInRange = 0 ,
  cNegOverflow = 1 ,
  cPosOverflow = 2
} ;

class bad_numeric_cast : public std::bad_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: overflow"; }
};

class negative_overflow : public bad_numeric_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: negative overflow"; }
};
class positive_overflow : public bad_numeric_cast
{
  public:

    virtual const char * what() const throw()
      { return "bad numeric conversion: positive overflow"; }
};

struct def_overflow_handler
{
  void operator() ( range_check_result r )
  {

    if ( r == cNegOverflow )
      throw negative_overflow() ;
    else if ( r == cPosOverflow )
           throw positive_overflow() ;






  }
} ;

struct silent_overflow_handler
{
  void operator() ( range_check_result ) {}
} ;

template<class Traits>
struct raw_converter
{
  typedef typename Traits::result_type result_type ;
  typedef typename Traits::argument_type argument_type ;

  static result_type low_level_convert ( argument_type s ) { return static_cast<result_type>(s) ; }
} ;

struct UseInternalRangeChecker {} ;

} }
# 15 "/usr/include/boost/numeric/conversion/converter.hpp" 2 3 4

# 1 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/bounds.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/bounds.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/bounds.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/bounds.hpp" 3 4
namespace boost { namespace numeric { namespace boundsdetail
{
  template<class N>
  class Integral
  {
      typedef std::numeric_limits<N> limits ;

    public :

      static N lowest () { return limits::min (); }
      static N highest () { return limits::max (); }
      static N smallest() { return static_cast<N>(1); }
  } ;

  template<class N>
  class Float
  {
      typedef std::numeric_limits<N> limits ;

    public :

      static N lowest () { return static_cast<N>(-limits::max ()) ; }
      static N highest () { return limits::max (); }
      static N smallest() { return limits::min (); }
  } ;

  template<class N>
  struct get_impl
  {
    typedef mpl::bool_< ::std::numeric_limits<N>::is_integer > is_int ;

    typedef Integral<N> impl_int ;
    typedef Float <N> impl_float ;

    typedef typename mpl::if_<is_int,impl_int,impl_float>::type type ;
  } ;

} } }
# 14 "/usr/include/boost/numeric/conversion/bounds.hpp" 2 3 4

namespace boost { namespace numeric
{

template<class N>
struct bounds : boundsdetail::get_impl<N>::type
{} ;

} }
# 18 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 2 3 4





namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<std::float_round_style, std::round_toward_zero> round2zero_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_to_nearest> round2nearest_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_toward_infinity> round2inf_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_toward_neg_infinity> round2neg_inf_c ;
# 40 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class RoundStyle,class RoundToZero,class RoundToNearest,class RoundToInf,class RoundToNegInf>
  struct for_round_style
  {
    typedef ct_switch4<RoundStyle
                       , round2zero_c, round2nearest_c, round2inf_c
                       , RoundToZero , RoundToNearest , RoundToInf , RoundToNegInf
                      > selector ;

    typedef typename selector::type type ;
  } ;
# 81 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  struct non_applicable { typedef mpl::false_ do_apply ; } ;
  struct applicable { typedef mpl::true_ do_apply ; } ;
# 96 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
    template<class Traits>
    struct LT_LoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(bounds<T>::lowest()) ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LT_Zero : applicable
    {
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(0) ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LE_PrevLoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s <= static_cast<S>(bounds<T>::lowest()) - static_cast<S>(1.0)
                 ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LT_HalfPrevLoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(bounds<T>::lowest()) - static_cast<S>(0.5)
                 ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GT_HiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s > static_cast<S>(bounds<T>::highest())
                 ? cPosOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GE_SuccHiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(1.0)
                 ? cPosOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GT_HalfSuccHiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(0.5)
                 ? cPosOverflow : cInRange ;
      }
    } ;
# 215 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
    template<class PredA, class PredB>
    struct applyBoth
    {
      typedef typename PredA::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        range_check_result r = PredA::apply(s) ;
        if ( r == cInRange )
          r = PredB::apply(s);
        return r ;
      }
    } ;

    template<class PredA, class PredB>
    struct combine
    {
      typedef applyBoth<PredA,PredB> Both ;
      typedef void NNone ;

      typedef typename PredA::do_apply do_applyA ;
      typedef typename PredB::do_apply do_applyB ;

      typedef typename for_both<do_applyA, do_applyB, Both, PredA, PredB, NNone>::type type ;
    } ;
# 262 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits>
  struct dummy_range_checker
  {
    typedef typename Traits::argument_type argument_type ;

    static range_check_result out_of_range ( argument_type ) { return cInRange ; }
    static void validate_range ( argument_type ) {}
  } ;
# 279 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits, class IsNegOverflow, class IsPosOverflow, class OverflowHandler>
  struct generic_range_checker
  {
    typedef OverflowHandler overflow_handler ;

    typedef typename Traits::argument_type argument_type ;

    static range_check_result out_of_range ( argument_type s )
    {
      typedef typename combine<IsNegOverflow,IsPosOverflow>::type Predicate ;

      return Predicate::apply(s);
    }

    static void validate_range ( argument_type s )
      { OverflowHandler()( out_of_range(s) ) ; }
  } ;
# 305 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits,class OverflowHandler>
  struct GetRC_Sig2Sig_or_Unsig2Unsig
  {
    typedef dummy_range_checker<Traits> Dummy ;

    typedef LT_LoT<Traits> Pred1 ;
    typedef GT_HiT<Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;

    typedef typename Traits::subranged subranged ;

    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Sig2Unsig
  {
    typedef LT_Zero<Traits> Pred1 ;
    typedef GT_HiT <Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ChoiceA ;

    typedef generic_range_checker<Traits,Pred1,non_applicable,OverflowHandler> ChoiceB ;

    typedef typename Traits::target_type T ;
    typedef typename Traits::source_type S ;

    typedef typename subranged_Unsig2Sig<S,T>::type oposite_subranged ;

    typedef typename mpl::not_<oposite_subranged>::type positively_subranged ;

    typedef typename mpl::if_<positively_subranged,ChoiceA,ChoiceB>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Unsig2Sig
  {
    typedef GT_HiT<Traits> Pred1 ;

    typedef generic_range_checker<Traits,non_applicable,Pred1,OverflowHandler> type ;
  } ;

  template<class Traits,class OverflowHandler>
  struct GetRC_Int2Int
  {
    typedef GetRC_Sig2Sig_or_Unsig2Unsig<Traits,OverflowHandler> Sig2SigQ ;
    typedef GetRC_Sig2Unsig <Traits,OverflowHandler> Sig2UnsigQ ;
    typedef GetRC_Unsig2Sig <Traits,OverflowHandler> Unsig2SigQ ;
    typedef Sig2SigQ Unsig2UnsigQ ;

    typedef typename Traits::sign_mixture sign_mixture ;

    typedef typename
      for_sign_mixture<sign_mixture,Sig2SigQ,Sig2UnsigQ,Unsig2SigQ,Unsig2UnsigQ>::type
        selector ;

    typedef typename selector::type type ;
  } ;

  template<class Traits>
  struct GetRC_Int2Float
  {
    typedef dummy_range_checker<Traits> type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC_Float2Int
  {
    typedef LE_PrevLoT <Traits> Pred1 ;
    typedef GE_SuccHiT <Traits> Pred2 ;
    typedef LT_HalfPrevLoT<Traits> Pred3 ;
    typedef GT_HalfSuccHiT<Traits> Pred4 ;
    typedef GT_HiT <Traits> Pred5 ;
    typedef LT_LoT <Traits> Pred6 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ToZero ;
    typedef generic_range_checker<Traits,Pred3,Pred4,OverflowHandler> ToNearest ;
    typedef generic_range_checker<Traits,Pred1,Pred5,OverflowHandler> ToInf ;
    typedef generic_range_checker<Traits,Pred6,Pred2,OverflowHandler> ToNegInf ;

    typedef typename Float2IntRounder::round_style round_style ;

    typedef typename for_round_style<round_style,ToZero,ToNearest,ToInf,ToNegInf>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Float2Float
  {
    typedef dummy_range_checker<Traits> Dummy ;

    typedef LT_LoT<Traits> Pred1 ;
    typedef GT_HiT<Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;

    typedef typename Traits::subranged subranged ;

    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC_BuiltIn2BuiltIn
  {
    typedef GetRC_Int2Int<Traits,OverflowHandler> Int2IntQ ;
    typedef GetRC_Int2Float<Traits> Int2FloatQ ;
    typedef GetRC_Float2Int<Traits,OverflowHandler,Float2IntRounder> Float2IntQ ;
    typedef GetRC_Float2Float<Traits,OverflowHandler> Float2FloatQ ;

    typedef typename Traits::int_float_mixture int_float_mixture ;

    typedef typename for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ>::type selector ;

    typedef typename selector::type type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC
  {
    typedef GetRC_BuiltIn2BuiltIn<Traits,OverflowHandler,Float2IntRounder> BuiltIn2BuiltInQ ;

    typedef dummy_range_checker<Traits> Dummy ;

    typedef mpl::identity<Dummy> DummyQ ;

    typedef typename Traits::udt_builtin_mixture udt_builtin_mixture ;

    typedef typename for_udt_builtin_mixture<udt_builtin_mixture,BuiltIn2BuiltInQ,DummyQ,DummyQ,DummyQ>::type selector ;

    typedef typename selector::type type ;
  } ;
# 452 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits>
  struct trivial_converter_impl : public std::unary_function< typename Traits::argument_type
                                                              ,typename Traits::result_type
                                                            >
                                 ,public dummy_range_checker<Traits>
  {
    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static result_type low_level_convert ( argument_type s ) { return s ; }
    static source_type nearbyint ( argument_type s ) { return s ; }
    static result_type convert ( argument_type s ) { return s ; }
  } ;





  template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
  struct rounding_converter : public std::unary_function< typename Traits::argument_type
                                                          ,typename Traits::result_type
                                                        >
                             ,public RangeChecker
                             ,public Float2IntRounder
                             ,public RawConverter
  {
    typedef RangeChecker RangeCheckerBase ;
    typedef Float2IntRounder Float2IntRounderBase ;
    typedef RawConverter RawConverterBase ;

    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static result_type convert ( argument_type s )
    {
      RangeCheckerBase::validate_range(s);
      source_type s1 = Float2IntRounderBase::nearbyint(s);
      return RawConverterBase::low_level_convert(s1);
    }
  } ;





  template<class Traits,class RangeChecker,class RawConverter>
  struct non_rounding_converter : public std::unary_function< typename Traits::argument_type
                                                             ,typename Traits::result_type
                                                           >
                                 ,public RangeChecker
                                 ,public RawConverter
  {
    typedef RangeChecker RangeCheckerBase ;
    typedef RawConverter RawConverterBase ;

    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static source_type nearbyint ( argument_type s ) { return s ; }

    static result_type convert ( argument_type s )
    {
      RangeCheckerBase::validate_range(s);
      return RawConverterBase::low_level_convert(s);
    }
  } ;
# 537 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits,class OverflowHandler,class Float2IntRounder,class RawConverter, class UserRangeChecker>
  struct get_non_trivial_converter
  {
    typedef GetRC<Traits,OverflowHandler,Float2IntRounder> InternalRangeCheckerQ ;

    typedef is_same<UserRangeChecker,UseInternalRangeChecker> use_internal_RC ;

    typedef mpl::identity<UserRangeChecker> UserRangeCheckerQ ;

    typedef typename
      mpl::eval_if<use_internal_RC,InternalRangeCheckerQ,UserRangeCheckerQ>::type
        RangeChecker ;

    typedef non_rounding_converter<Traits,RangeChecker,RawConverter> NonRounding ;
    typedef rounding_converter<Traits,RangeChecker,RawConverter,Float2IntRounder> Rounding ;

    typedef mpl::identity<NonRounding> NonRoundingQ ;
    typedef mpl::identity<Rounding> RoundingQ ;

    typedef typename Traits::int_float_mixture int_float_mixture ;

    typedef typename
      for_int_float_mixture<int_float_mixture, NonRoundingQ, NonRoundingQ, RoundingQ, NonRoundingQ>::type
        selector ;

    typedef typename selector::type type ;
  } ;

  template< class Traits
           ,class OverflowHandler
           ,class Float2IntRounder
           ,class RawConverter
           ,class UserRangeChecker
          >
  struct get_converter_impl
  {
# 583 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
    typedef trivial_converter_impl<Traits> Trivial ;
    typedef mpl::identity <Trivial> TrivialQ ;

    typedef get_non_trivial_converter< Traits
                                      ,OverflowHandler
                                      ,Float2IntRounder
                                      ,RawConverter
                                      ,UserRangeChecker
                                     > NonTrivialQ ;

    typedef typename Traits::trivial trivial ;

    typedef typename mpl::eval_if<trivial,TrivialQ,NonTrivialQ>::type type ;
  } ;

} } }
# 17 "/usr/include/boost/numeric/conversion/converter.hpp" 2 3 4

namespace boost { namespace numeric
{

template<class T,
         class S,
         class Traits = conversion_traits<T,S>,
         class OverflowHandler = def_overflow_handler,
         class Float2IntRounder = Trunc< typename Traits::source_type> ,
         class RawConverter = raw_converter<Traits>,
         class UserRangeChecker = UseInternalRangeChecker
        >
struct converter : convdetail::get_converter_impl<Traits,
                                                  OverflowHandler,
                                                  Float2IntRounder,
                                                  RawConverter,
                                                  UserRangeChecker
                                                 >::type
{
  typedef Traits traits ;

  typedef typename Traits::argument_type argument_type ;
  typedef typename Traits::result_type result_type ;

  result_type operator() ( argument_type s ) const { return this->convert(s) ; }
} ;



template<class S,
         class OverflowHandler = def_overflow_handler,
         class Float2IntRounder = Trunc<S> ,
         class UserRangeChecker = UseInternalRangeChecker
        >
struct make_converter_from
{
  template<class T,
           class Traits = conversion_traits<T,S>,
           class RawConverter = raw_converter<Traits>
          >
  struct to
  {
    typedef converter<T,S,Traits,OverflowHandler,Float2IntRounder,RawConverter,UserRangeChecker> type ;
  } ;

} ;

} }
# 34 "/usr/include/boost/numeric/conversion/cast.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 1 3 4
# 14 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 3 4
namespace boost { namespace numeric {

    template <typename Target, typename Source, typename EnableIf = void>
    struct numeric_cast_traits
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<Source> rounding_policy;
    };

}}


# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 28 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 1 3 4
# 12 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp" 1 3 4
# 12 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp" 3 4
namespace boost { namespace numeric {

    template <>
    struct numeric_cast_traits
        <
            char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };
}}
# 13 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 2 3 4


# 1 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp" 1 3 4
# 9 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp" 3 4
namespace boost { namespace numeric {


    template <>
    struct numeric_cast_traits
        <
            char
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::long_long_type
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::long_long_type
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::ulong_long_type
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::ulong_long_type
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };
}}
# 16 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 2 3 4
# 29 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 2 3 4
# 35 "/usr/include/boost/numeric/conversion/cast.hpp" 2 3 4

namespace boost
{
    template <typename Target, typename Source>
    inline Target numeric_cast( Source arg )
    {
        typedef numeric::conversion_traits<Target, Source> conv_traits;
        typedef numeric::numeric_cast_traits<Target, Source> cast_traits;
        typedef boost::numeric::converter
            <
                Target,
                Source,
                conv_traits,
                typename cast_traits::overflow_policy,
                typename cast_traits::rounding_policy,
                boost::numeric::raw_converter< conv_traits >,
                typename cast_traits::range_checking_policy
            > converter;
        return converter::convert(arg);
    }

    using numeric::bad_numeric_cast;
}
# 160 "/usr/include/boost/lexical_cast.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/has_left_shift.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/has_left_shift.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_fundamental.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/is_fundamental.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/is_fundamental.hpp" 2 3 4

namespace boost {

namespace detail {

template <typename T>
struct is_fundamental_impl
    : public ::boost::type_traits::ice_or<
          ::boost::is_arithmetic<T>::value
        , ::boost::is_void<T>::value
        >
{
};

}





template< typename T > struct is_fundamental : public ::boost::integral_constant<bool,::boost::detail::is_fundamental_impl<T>::value> { public: };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 44 "/usr/include/boost/type_traits/is_fundamental.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
# 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
# 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
          
# 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_left_shift_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator << (const any&, const any&);
# 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
struct returns_void_t { };
template <typename T> int operator,(const T&, returns_void_t);
template <typename T> int operator,(const volatile T&, returns_void_t);




template < typename Lhs, typename Rhs >
struct operator_returns_void {


   static ::boost::type_traits::yes_type returns_void(returns_void_t);
   static ::boost::type_traits::no_type returns_void(int);
   static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() << make<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, void, true > {
   static const bool value = true;
};

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, void, false > {
   static const bool value = false;
};

template < typename Lhs, typename Rhs, typename Ret >
struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Lhs, typename Rhs, typename Ret >
struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
   static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
   static ::boost::type_traits::no_type is_convertible_to_Ret(...);

   static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() << make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < typename Lhs, typename Rhs >
struct operator_exists {
   static ::boost::type_traits::yes_type check(has_operator);
   static ::boost::type_traits::no_type check(no_operator);

   static const bool value = (sizeof(check(((make<Lhs>() << make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl1 < Lhs, Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl1 < Lhs, Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )






    ;
};


template < typename Rhs, typename Ret >
struct trait_impl1 < void, Rhs, Ret, false > {
   static const bool value = false;
};

template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, void, Ret, false > {
   static const bool value = false;
};

template < typename Ret >
struct trait_impl1 < void, void, Ret, false > {
   static const bool value = false;
};


template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
   static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_left_shift_impl::dont_care > struct has_left_shift : public ::boost::integral_constant<bool,(::boost::detail::has_left_shift_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/usr/include/boost/type_traits/has_left_shift.hpp" 2 3 4
# 166 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_right_shift.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/has_right_shift.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3 4
# 40 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3 4
          
# 41 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_right_shift_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator >> (const any&, const any&);
# 82 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
struct returns_void_t { };
template <typename T> int operator,(const T&, returns_void_t);
template <typename T> int operator,(const volatile T&, returns_void_t);




template < typename Lhs, typename Rhs >
struct operator_returns_void {


   static ::boost::type_traits::yes_type returns_void(returns_void_t);
   static ::boost::type_traits::no_type returns_void(int);
   static const bool value = (sizeof(::boost::type_traits::yes_type)==sizeof(returns_void((make<Lhs>() >> make<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Lhs, typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, void, true > {
   static const bool value = true;
};

template < typename Lhs, typename Rhs >
struct operator_returns_Ret < Lhs, Rhs, void, false > {
   static const bool value = false;
};

template < typename Lhs, typename Rhs, typename Ret >
struct operator_returns_Ret < Lhs, Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Lhs, typename Rhs, typename Ret >
struct operator_returns_Ret < Lhs, Rhs, Ret, false > {
   static ::boost::type_traits::yes_type is_convertible_to_Ret(Ret);
   static ::boost::type_traits::no_type is_convertible_to_Ret(...);

   static const bool value = (sizeof(is_convertible_to_Ret(make<Lhs>() >> make<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 150 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < typename Lhs, typename Rhs >
struct operator_exists {
   static ::boost::type_traits::yes_type check(has_operator);
   static ::boost::type_traits::no_type check(no_operator);

   static const bool value = (sizeof(check(((make<Lhs>() >> make<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 169 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
template < typename Lhs, typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl1 < Lhs, Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl1 < Lhs, Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs, Rhs >::value, operator_returns_Ret < Lhs, Rhs, Ret, operator_returns_void < Lhs, Rhs >::value >::value >::value )






    ;
};


template < typename Rhs, typename Ret >
struct trait_impl1 < void, Rhs, Ret, false > {
   static const bool value = false;
};

template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, void, Ret, false > {
   static const bool value = false;
};

template < typename Ret >
struct trait_impl1 < void, void, Ret, false > {
   static const bool value = false;
};


template < typename Lhs, typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Rhs_noref>::type >::type >::type Rhs_noptr;
   static const bool value = (trait_impl1 < Lhs_noref, Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_or< ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_right_shift_impl::dont_care > struct has_right_shift : public ::boost::integral_constant<bool,(::boost::detail::has_right_shift_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 229 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/usr/include/boost/type_traits/has_right_shift.hpp" 2 3 4
# 167 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/boost/math/special_functions/sign.hpp" 1 3 4
# 16 "/usr/include/boost/math/special_functions/sign.hpp" 3 4
# 1 "/usr/include/boost/math/tools/config.hpp" 1 3 4
# 14 "/usr/include/boost/math/tools/config.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/math/tools/config.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 19 "/usr/include/boost/math/tools/config.hpp" 2 3 4
# 1 "/usr/include/c++/4.8/cfloat" 1 3 4
# 39 "/usr/include/c++/4.8/cfloat" 3 4
       
# 40 "/usr/include/c++/4.8/cfloat" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/float.h" 1 3 4
# 42 "/usr/include/c++/4.8/cfloat" 2 3
# 20 "/usr/include/boost/math/tools/config.hpp" 2 3 4




# 1 "/usr/include/boost/math/tools/user.hpp" 1 3 4
# 25 "/usr/include/boost/math/tools/config.hpp" 2 3 4
# 1 "/usr/include/boost/math/special_functions/detail/round_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/math/special_functions/detail/round_fwd.hpp" 3 4
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);


   }
}
# 26 "/usr/include/boost/math/tools/config.hpp" 2 3 4
# 254 "/usr/include/boost/math/tools/config.hpp" 3 4
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&)
{
}

}}



# 1 "/usr/include/boost/detail/fenv.hpp" 1 3 4
# 69 "/usr/include/boost/detail/fenv.hpp" 3 4
# 1 "/usr/include/c++/4.8/fenv.h" 1 3 4
# 32 "/usr/include/c++/4.8/fenv.h" 3 4
       
# 33 "/usr/include/c++/4.8/fenv.h" 3



# 1 "/usr/include/fenv.h" 1 3 4
# 57 "/usr/include/fenv.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/fenv.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/fenv.h" 3 4
enum
  {
    FE_INVALID =

      0x01,
    __FE_DENORM = 0x02,
    FE_DIVBYZERO =

      0x04,
    FE_OVERFLOW =

      0x08,
    FE_UNDERFLOW =

      0x10,
    FE_INEXACT =

      0x20
  };







enum
  {
    FE_TONEAREST =

      0,
    FE_DOWNWARD =

      0x400,
    FE_UPWARD =

      0x800,
    FE_TOWARDZERO =

      0xc00
  };



typedef unsigned short int fexcept_t;






typedef struct
  {
    unsigned short int __control_word;
    unsigned short int __unused1;
    unsigned short int __status_word;
    unsigned short int __unused2;
    unsigned short int __tags;
    unsigned short int __unused3;
    unsigned int __eip;
    unsigned short int __cs_selector;
    unsigned int __opcode:11;
    unsigned int __unused4:5;
    unsigned int __data_offset;
    unsigned short int __data_selector;
    unsigned short int __unused5;



  }
fenv_t;
# 106 "/usr/include/i386-linux-gnu/bits/fenv.h" 3 4
extern "C" {


extern int __feraiseexcept_renamed (int) throw () __asm__ ("" "feraiseexcept");
extern __inline __attribute__ ((__gnu_inline__)) int
__attribute__ ((__leaf__)) feraiseexcept (int __excepts) throw ()
{
  if (__builtin_constant_p (__excepts)
      && (__excepts & ~(0x01 | 0x04)) == 0)
    {
      if ((0x01 & __excepts) != 0)
 {

   float __f = 0.0;




   __asm__ __volatile__ ("fdiv %%st, %%st(0); fwait"
    : "=t" (__f) : "0" (__f));

   (void) &__f;
 }
      if ((0x04 & __excepts) != 0)
 {
   float __f = 1.0;
   float __g = 0.0;




   __asm__ __volatile__ ("fdivp %%st, %%st(1); fwait"
    : "=t" (__f) : "0" (__f), "u" (__g) : "st(1)");

   (void) &__f;
 }

      return 0;
    }

  return __feraiseexcept_renamed (__excepts);
}

}
# 58 "/usr/include/fenv.h" 2 3 4

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 ();




# 1 "/usr/include/i386-linux-gnu/bits/fenvinline.h" 1 3 4
# 115 "/usr/include/fenv.h" 2 3 4







extern int feenableexcept (int __excepts) throw ();




extern int fedisableexcept (int __excepts) throw ();


extern int fegetexcept (void) throw ();


}
# 37 "/usr/include/c++/4.8/fenv.h" 2 3
# 70 "/usr/include/boost/detail/fenv.hpp" 2 3 4
# 282 "/usr/include/boost/math/tools/config.hpp" 2 3 4



namespace boost{ namespace math{
   namespace detail
   {
   struct fpu_guard
   {
      fpu_guard()
      {
         fegetexceptflag(&m_flags, (0x20 | 0x04 | 0x10 | 0x08 | 0x01));
         feclearexcept((0x20 | 0x04 | 0x10 | 0x08 | 0x01));
      }
      ~fpu_guard()
      {
         fesetexceptflag(&m_flags, (0x20 | 0x04 | 0x10 | 0x08 | 0x01));
      }
   private:
      fexcept_t m_flags;
   };

   }
   }}
# 17 "/usr/include/boost/math/special_functions/sign.hpp" 2 3 4
# 1 "/usr/include/boost/math/special_functions/math_fwd.hpp" 1 3 4
# 27 "/usr/include/boost/math/special_functions/math_fwd.hpp" 3 4
# 1 "/usr/include/boost/math/tools/promotion.hpp" 1 3 4
# 42 "/usr/include/boost/math/tools/promotion.hpp" 3 4
namespace boost
{
  namespace math
  {
    namespace tools
    {
# 68 "/usr/include/boost/math/tools/promotion.hpp" 3 4
      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;







      };

    }
  }
}
# 28 "/usr/include/boost/math/special_functions/math_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/math/policies/policy.hpp" 1 3 4
# 9 "/usr/include/boost/math/policies/policy.hpp" 3 4
# 1 "/usr/include/boost/mpl/list.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/list.hpp" 3 4
# 1 "/usr/include/boost/mpl/limits/list.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/list.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/list.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/list20.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/list/list20.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/list10.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/list/list10.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/list0.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/list0.hpp" 3 4
# 1 "/usr/include/boost/mpl/long.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/long.hpp" 3 4
# 1 "/usr/include/boost/mpl/long_fwd.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/long_fwd.hpp" 3 4
namespace mpl_ {

template< long N > struct long_;

}
namespace boost { namespace mpl { using ::mpl_::long_; } }
# 18 "/usr/include/boost/mpl/long.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< long N >
struct long_
{
    static const long value = N;





    typedef long_ type;

    typedef long value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    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;


}
# 21 "/usr/include/boost/mpl/long.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/list/aux_/push_front.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/push_front.hpp" 3 4
# 1 "/usr/include/boost/mpl/push_front_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/push_front_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct push_front_impl;
template< typename Sequence, typename T > struct push_front;

}}
# 18 "/usr/include/boost/mpl/list/aux_/push_front.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/list/aux_/item.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/list/aux_/item.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/aux_/tag.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/tag.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

struct list_tag;
struct l_iter_tag;

}}}
# 19 "/usr/include/boost/mpl/list/aux_/item.hpp" 2 3 4



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;
};

}}
# 20 "/usr/include/boost/mpl/list/aux_/push_front.hpp" 2 3 4


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;
    };
};

}}
# 20 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/pop_front.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/pop_front.hpp" 3 4
# 1 "/usr/include/boost/mpl/pop_front_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/pop_front_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct pop_front_impl;
template< typename Sequence > struct pop_front;

}}
# 18 "/usr/include/boost/mpl/list/aux_/pop_front.hpp" 2 3 4



namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef typename mpl::next<List>::type type;
    };
};

}}
# 21 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/push_back.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/push_back.hpp" 3 4
# 1 "/usr/include/boost/mpl/push_back_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/push_back_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct push_back_impl;
template< typename Sequence, typename T > struct push_back;

}}
# 18 "/usr/include/boost/mpl/list/aux_/push_back.hpp" 2 3 4



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_
    {
    };
};

}}
# 22 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/front.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/front.hpp" 3 4
# 1 "/usr/include/boost/mpl/front_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/front_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct front_impl;
template< typename Sequence > struct front;

}}
# 18 "/usr/include/boost/mpl/list/aux_/front.hpp" 2 3 4


namespace boost { namespace mpl {

template<>
struct front_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef typename List::item type;
    };
};

}}
# 23 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/clear.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/clear.hpp" 3 4
# 1 "/usr/include/boost/mpl/clear_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/clear_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct clear_impl;
template< typename Sequence > struct clear;

}}
# 18 "/usr/include/boost/mpl/list/aux_/clear.hpp" 2 3 4



namespace boost { namespace mpl {

template<>
struct clear_impl< aux::list_tag >
{
    template< typename List > struct apply
    {
        typedef l_end type;
    };
};

}}
# 24 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/O1_size.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/O1_size.hpp" 3 4
# 1 "/usr/include/boost/mpl/O1_size_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/O1_size_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct O1_size_impl;
template< typename Sequence > struct O1_size;

}}
# 18 "/usr/include/boost/mpl/list/aux_/O1_size.hpp" 2 3 4


namespace boost { namespace mpl {

template<>
struct O1_size_impl< aux::list_tag >
{
    template< typename List > struct apply
        : List::size
    {
    };
};

}}
# 25 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/size.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/size.hpp" 3 4
# 1 "/usr/include/boost/mpl/size_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/size_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct size_impl;
template< typename Sequence > struct size;

}}
# 18 "/usr/include/boost/mpl/list/aux_/size.hpp" 2 3 4


namespace boost { namespace mpl {

template<>
struct size_impl< aux::list_tag >
{
    template< typename List > struct apply
        : List::size
    {
    };
};

}}
# 26 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/empty.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/empty.hpp" 3 4
# 1 "/usr/include/boost/mpl/empty_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/empty_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct empty_impl;
template< typename Sequence > struct empty;

}}
# 18 "/usr/include/boost/mpl/list/aux_/empty.hpp" 2 3 4



namespace boost { namespace mpl {

template<>
struct empty_impl< aux::list_tag >
{
    template< typename List > struct apply
        : not_<typename List::size>
    {
    };
};

}}
# 27 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/begin_end.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/begin_end.hpp" 3 4
# 1 "/usr/include/boost/mpl/begin_end_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/begin_end_fwd.hpp" 3 4
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;

}}
# 18 "/usr/include/boost/mpl/list/aux_/begin_end.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/list/aux_/iterator.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/list/aux_/iterator.hpp" 3 4
# 1 "/usr/include/boost/mpl/iterator_tags.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/iterator_tags.hpp" 3 4
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; };

}}
# 18 "/usr/include/boost/mpl/list/aux_/iterator.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/deref.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/deref.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
# 48 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
template< typename T > struct msvc_type
{
    typedef typename T::type type;
};

template<> struct msvc_type<int>
{
    typedef int type;
};



}}}
# 18 "/usr/include/boost/mpl/deref.hpp" 2 3 4




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> { }; }

}}
# 20 "/usr/include/boost/mpl/list/aux_/iterator.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/lambda_spec.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/list/aux_/iterator.hpp" 2 3 4


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;
};
# 62 "/usr/include/boost/mpl/list/aux_/iterator.hpp" 3 4
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; };

}}
# 19 "/usr/include/boost/mpl/list/aux_/begin_end.hpp" 2 3 4



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;
    };
};

}}
# 28 "/usr/include/boost/mpl/list/list0.hpp" 2 3 4


namespace boost { namespace mpl {

template< typename Dummy = na > struct list0;

template<> struct list0<na>
    : l_end
{
    typedef l_end type;
};

}}
# 19 "/usr/include/boost/mpl/list/list10.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/list/list10.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/aux_/include_preprocessed.hpp" 1 3 4
# 30 "/usr/include/boost/mpl/list/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/aux_/preprocessed/plain/list10.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/list/aux_/preprocessed/plain/list10.hpp" 3 4
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;
};

}}
# 31 "/usr/include/boost/mpl/list/aux_/include_preprocessed.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/list/list10.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/list/list20.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/list/list20.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/aux_/include_preprocessed.hpp" 1 3 4
# 30 "/usr/include/boost/mpl/list/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/list/aux_/preprocessed/plain/list20.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/list/aux_/preprocessed/plain/list20.hpp" 3 4
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;
};

}}
# 31 "/usr/include/boost/mpl/list/aux_/include_preprocessed.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/list/list20.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/list.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/list.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/list.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/list.hpp" 3 4
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;
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 47 "/usr/include/boost/mpl/list.hpp" 2 3 4
# 10 "/usr/include/boost/math/policies/policy.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/contains.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/contains.hpp" 3 4
# 1 "/usr/include/boost/mpl/contains_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/contains_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct contains_impl;
template< typename Sequence, typename T > struct contains;

}}
# 19 "/usr/include/boost/mpl/contains.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/sequence_tag.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 3 4
namespace boost { namespace mpl {

struct nested_begin_end_tag;
struct non_sequence_tag;

template< typename Sequence > struct sequence_tag;

}}
# 18 "/usr/include/boost/mpl/sequence_tag.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/has_begin.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_begin.hpp" 3 4
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; };
}}}
# 20 "/usr/include/boost/mpl/sequence_tag.hpp" 2 3 4






namespace boost { namespace mpl {
# 78 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
namespace aux {

template< bool has_tag_, bool has_begin_ >
struct sequence_tag_impl
{


    template< typename Sequence > struct result2_;
};
# 98 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
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> { }; }

}}
# 20 "/usr/include/boost/mpl/contains.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/begin_end.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/begin_end.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/traits_lambda_spec.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4


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;
    };
};
# 82 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
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; }; };







}}
# 19 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4




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> { }; }

}}
# 20 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/find.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/find.hpp" 3 4
# 1 "/usr/include/boost/mpl/find_if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/find_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 1 3 4
# 14 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 2 3 4


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
        >
{
};

}}}
# 15 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 2 3 4


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;
    };
};

}}}
# 18 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/iter_fold_if.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/iter_fold_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/pair.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/pair.hpp" 3 4
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> { }; }

}}
# 24 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 3 4
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;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4







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> { }; }

}}
# 20 "/usr/include/boost/mpl/find_if.hpp" 2 3 4




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> { }; }

}}
# 18 "/usr/include/boost/mpl/find.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/same_as.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/same_as.hpp" 3 4
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> >
    {




    };
};

}}
# 19 "/usr/include/boost/mpl/find.hpp" 2 3 4



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> { }; }

}}
# 21 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 2 3 4







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
            > >
    {
# 54 "/usr/include/boost/mpl/aux_/contains_impl.hpp" 3 4
    };
};

 template<> struct contains_impl<non_sequence_tag> {};

}}
# 21 "/usr/include/boost/mpl/contains.hpp" 2 3 4



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> { }; }

}}
# 11 "/usr/include/boost/math/policies/policy.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/remove_if.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/remove_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/fold.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/fold.hpp" 3 4
# 1 "/usr/include/boost/mpl/O1_size.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/O1_size.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_size.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_size.hpp" 3 4
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; };
}}}
# 21 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 2 3 4





namespace boost { namespace mpl {
# 35 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
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
    {
# 69 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
    };
};
# 85 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
}}
# 20 "/usr/include/boost/mpl/O1_size.hpp" 2 3 4



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> { }; }

}}
# 20 "/usr/include/boost/mpl/fold.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
# 34 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp" 3 4
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;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/aux_/fold_impl.hpp" 2 3 4
# 21 "/usr/include/boost/mpl/fold.hpp" 2 3 4



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> { }; }

}}
# 19 "/usr/include/boost/mpl/remove_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/reverse_fold.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/reverse_fold.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/reverse_fold.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp" 3 4
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;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2 3 4
# 22 "/usr/include/boost/mpl/reverse_fold.hpp" 2 3 4


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> { }; }

}}
# 20 "/usr/include/boost/mpl/remove_if.hpp" 2 3 4




# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/remove_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 3 4
# 1 "/usr/include/boost/mpl/back_inserter.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/back_inserter.hpp" 3 4
# 1 "/usr/include/boost/mpl/push_back.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/push_back.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/push_back_impl.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/aux_/push_back_impl.hpp" 3 4
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> {};

}}
# 19 "/usr/include/boost/mpl/push_back.hpp" 2 3 4




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> { }; }

}}
# 19 "/usr/include/boost/mpl/back_inserter.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/inserter.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/inserter.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Sequence
    , typename Operation
    >
struct inserter
{
    typedef Sequence state;
    typedef Operation operation;
};

}}
# 20 "/usr/include/boost/mpl/back_inserter.hpp" 2 3 4

namespace boost {
namespace mpl {

template<
      typename Sequence
    >
struct back_inserter
    : inserter< Sequence,push_back<> >
{
};

}}
# 19 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/front_inserter.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/front_inserter.hpp" 3 4
# 1 "/usr/include/boost/mpl/push_front.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/push_front.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/push_front_impl.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/aux_/push_front_impl.hpp" 3 4
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> {};

}}
# 19 "/usr/include/boost/mpl/push_front.hpp" 2 3 4




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> { }; }

}}
# 19 "/usr/include/boost/mpl/front_inserter.hpp" 2 3 4


namespace boost { namespace mpl {

template<
      typename Sequence
    >
struct front_inserter
    : inserter< Sequence,push_front<> >
{
};

}}
# 20 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4




# 1 "/usr/include/boost/mpl/clear.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/clear.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/clear_impl.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/clear_impl.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag >
struct clear_impl
{
    template< typename Sequence > struct apply;
};

 template<> struct clear_impl<non_sequence_tag> {};

}}
# 19 "/usr/include/boost/mpl/clear.hpp" 2 3 4




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> { }; }

}}
# 25 "/usr/include/boost/mpl/aux_/inserter_algorithm.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/remove_if.hpp" 2 3 4

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> { }; }

}}
# 14 "/usr/include/boost/math/policies/policy.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/vector.hpp" 3 4
# 1 "/usr/include/boost/mpl/limits/vector.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/vector.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/vector.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/vector20.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/vector/vector20.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/vector10.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/vector/vector10.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/vector0.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/vector/vector0.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/at.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/vector/aux_/at.hpp" 3 4
# 1 "/usr/include/boost/mpl/at_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/at_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct at_impl;
template< typename Sequence, typename N > struct at;

}}
# 18 "/usr/include/boost/mpl/vector/aux_/at.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/tag.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/vector/aux_/tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/typeof.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/vector/aux_/tag.hpp" 2 3 4


namespace boost { namespace mpl { namespace aux {

struct v_iter_tag;


struct vector_tag;




}}}
# 19 "/usr/include/boost/mpl/vector/aux_/at.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/vector/aux_/at.hpp" 3 4
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
            >
    {
    };
};
# 114 "/usr/include/boost/mpl/vector/aux_/at.hpp" 3 4
}}
# 18 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/front.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/vector/aux_/front.hpp" 3 4
namespace boost { namespace mpl {



template<>
struct front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<Vector,0>
    {
    };
};
# 54 "/usr/include/boost/mpl/vector/aux_/front.hpp" 3 4
}}
# 19 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/item.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/vector/aux_/item.hpp" 3 4
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_;
};



}}
# 23 "/usr/include/boost/mpl/vector/aux_/push_front.hpp" 2 3 4


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;
    };
};

}}
# 20 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/pop_front.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/vector/aux_/pop_front.hpp" 3 4
namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,1> type;
    };
};

}}
# 21 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/push_back.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/vector/aux_/push_back.hpp" 3 4
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;
    };
};

}}
# 22 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/pop_back.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/vector/aux_/pop_back.hpp" 3 4
# 1 "/usr/include/boost/mpl/pop_back_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/pop_back_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct pop_back_impl;
template< typename Sequence > struct pop_back;

}}
# 18 "/usr/include/boost/mpl/vector/aux_/pop_back.hpp" 2 3 4







namespace boost { namespace mpl {

template<>
struct pop_back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,0> type;
    };
};

}}
# 23 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/back.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/vector/aux_/back.hpp" 3 4
# 1 "/usr/include/boost/mpl/back_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/back_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct back_impl;
template< typename Sequence > struct back;

}}
# 18 "/usr/include/boost/mpl/vector/aux_/back.hpp" 2 3 4






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
            >
    {
    };
};
# 57 "/usr/include/boost/mpl/vector/aux_/back.hpp" 3 4
}}
# 24 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
# 1 "/usr/include/boost/mpl/plus.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/plus.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 3 4
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
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/plus.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/minus.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/minus.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 3 4
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
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/minus.hpp" 2 3 4
# 21 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/advance_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/advance_fwd.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;

}}
# 22 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/distance_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/distance_fwd.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag > struct distance_impl;
template< typename First, typename Last > struct distance;

}}
# 23 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/prior.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 2 3 4





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;
# 56 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
};




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_)>
{
};
# 128 "/usr/include/boost/mpl/vector/aux_/iterator.hpp" 3 4
}}
# 23 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 2 3 4



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_(...);
# 48 "/usr/include/boost/mpl/vector/aux_/vector0.hpp" 3 4
};

}}
# 19 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 2 3 4




namespace boost { namespace mpl {



template<>
struct clear_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef vector0<> type;
    };
};
# 53 "/usr/include/boost/mpl/vector/aux_/clear.hpp" 3 4
}}
# 25 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/O1_size.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/vector/aux_/O1_size.hpp" 3 4
namespace boost { namespace mpl {



template<>
struct O1_size_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : Vector::size
    {
    };
};
# 54 "/usr/include/boost/mpl/vector/aux_/O1_size.hpp" 3 4
}}
# 26 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/size.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/vector/aux_/size.hpp" 3 4
namespace boost { namespace mpl {



template<>
struct size_impl< aux::vector_tag >
    : O1_size_impl< aux::vector_tag >
{
};
# 47 "/usr/include/boost/mpl/vector/aux_/size.hpp" 3 4
}}
# 27 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 3 4
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_
            >
    {
    };
};
# 66 "/usr/include/boost/mpl/vector/aux_/empty.hpp" 3 4
}}
# 28 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/vector/aux_/begin_end.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/vector/aux_/begin_end.hpp" 3 4
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;
    };
};

}}
# 32 "/usr/include/boost/mpl/vector/vector0.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/vector/vector10.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/vector/vector10.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 1 3 4
# 49 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 3 4
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;
};

}}
# 50 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/vector/vector10.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/vector/vector20.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/vector/vector20.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 1 3 4
# 49 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 3 4
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;
};

}}
# 50 "/usr/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/vector/vector20.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/vector.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/vector.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp" 3 4
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;
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 47 "/usr/include/boost/mpl/vector.hpp" 2 3 4
# 15 "/usr/include/boost/math/policies/policy.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/at.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/at.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/at_impl.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/at_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/advance.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/advance.hpp" 3 4
# 1 "/usr/include/boost/mpl/negate.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/negate.hpp" 3 4
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> { }; }
# 65 "/usr/include/boost/mpl/negate.hpp" 3 4
template<>
struct negate_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (-N::value) >

    {
    };
};

}}
# 20 "/usr/include/boost/mpl/advance.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/advance.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 3 4
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;
    };
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/advance_forward.hpp" 2 3 4
# 25 "/usr/include/boost/mpl/advance.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 3 4
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;
    };
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/advance_backward.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/advance.hpp" 2 3 4




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> { }; }

}}
# 19 "/usr/include/boost/mpl/aux_/at_impl.hpp" 2 3 4



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> {};

}}
# 19 "/usr/include/boost/mpl/at.hpp" 2 3 4






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> { }; }

}}
# 17 "/usr/include/boost/math/policies/policy.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/size.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/size.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/size_impl.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/size_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/distance.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/distance.hpp" 3 4
# 1 "/usr/include/boost/mpl/iter_fold.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/iter_fold.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 3 4
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;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 34 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
# 22 "/usr/include/boost/mpl/iter_fold.hpp" 2 3 4



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> { }; }

}}
# 19 "/usr/include/boost/mpl/distance.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/iterator_range.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/iterator_range.hpp" 3 4
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> { }; }

}}
# 20 "/usr/include/boost/mpl/distance.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/distance.hpp" 2 3 4







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 >
    {
# 60 "/usr/include/boost/mpl/distance.hpp" 3 4
    };
};

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> { }; }

}}
# 20 "/usr/include/boost/mpl/aux_/size_impl.hpp" 2 3 4



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> {};

}}
# 20 "/usr/include/boost/mpl/size.hpp" 2 3 4




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> { }; }

}}
# 18 "/usr/include/boost/math/policies/policy.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/comparison.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/comparison.hpp" 3 4
# 1 "/usr/include/boost/mpl/not_equal_to.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/not_equal_to.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp" 3 4
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 ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/not_equal_to.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/comparison.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/greater.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/greater.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp" 3 4
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 ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/greater.hpp" 2 3 4
# 21 "/usr/include/boost/mpl/comparison.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/less_equal.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/less_equal.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp" 3 4
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 ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/less_equal.hpp" 2 3 4
# 22 "/usr/include/boost/mpl/comparison.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/greater_equal.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/greater_equal.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp" 3 4
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 ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/greater_equal.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/comparison.hpp" 2 3 4
# 19 "/usr/include/boost/math/policies/policy.hpp" 2 3 4


# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 22 "/usr/include/boost/math/policies/policy.hpp" 2 3 4




# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 27 "/usr/include/boost/math/policies/policy.hpp" 2 3 4

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 29 "/usr/include/boost/math/policies/policy.hpp" 2 3 4


namespace boost{ namespace math{

namespace tools{

template <class T>
int digits();
template <class T>
T epsilon();

}

namespace policies{
# 176 "/usr/include/boost/math/policies/policy.hpp" 3 4
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>, assert_undefined<> >::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>, typename Policy::assert_undefined_type >::type assert_undefined_type;



   typedef typename detail::find_arg<arg_list, is_max_series_iterations<mpl::_1>, typename Policy::max_series_iterations_type>::type max_series_iterations_type;
   typedef typename detail::find_arg<arg_list, is_max_root_iterations<mpl::_1>, typename Policy::max_root_iterations_type>::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;
};
# 776 "/usr/include/boost/math/policies/policy.hpp" 3 4
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;
# 812 "/usr/include/boost/math/policies/policy.hpp" 3 4
};



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;
};

}}}
# 29 "/usr/include/boost/math/special_functions/math_fwd.hpp" 2 3 4

# 1 "/usr/include/boost/config/no_tr1/complex.hpp" 1 3 4
# 31 "/usr/include/boost/math/special_functions/math_fwd.hpp" 2 3 4



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 T1, class T2, class Policy>
   std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_1(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_1(T1 v, T2 x);

   template <class T1, class T2, class Policy>
   std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> cyl_hankel_2(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> cyl_hankel_2(T1 v, T2 x);

   template <class T1, class T2, class Policy>
   std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_1(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_1(T1 v, T2 x);

   template <class T1, class T2, class Policy>
   std::complex<typename detail::bessel_traits<T1, T2, Policy>::result_type> sph_hankel_2(T1 v, T2 x, const Policy& pol);

   template <class T1, class T2>
   std::complex<typename detail::bessel_traits<T1, T2, policies::policy<> >::result_type> sph_hankel_2(T1 v, T2 x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type airy_ai(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type airy_ai(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type airy_bi(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type airy_bi(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type airy_ai_prime(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type airy_ai_prime(T x);

   template <class T, class Policy>
   typename tools::promote_args<T>::type airy_bi_prime(T x, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type airy_bi_prime(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 T1, class T2, class Policy>
   typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a, const Policy& pol);

   template <class T1, class T2>
   typename tools::promote_args<T1, T2>::type owens_t(T1 h, T2 a);


   template <class T, class Policy>
   typename tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn, T* pdn, const Policy&);

   template <class T>
   typename tools::promote_args<T>::type jacobi_elliptic(T k, T theta, T* pcn = 0, T* pdn = 0);

   template <class U, class T, class Policy>
   typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta, const Policy& pol);

   template <class U, class T>
   typename tools::promote_args<T, U>::type jacobi_sn(U k, T theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_cn(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_dn(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_cd(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_dc(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_ns(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_sd(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_ds(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_nc(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_nd(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_sc(T k, U theta);

   template <class T, class U, class Policy>
   typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta, const Policy& pol);

   template <class T, class U>
   typename tools::promote_args<T, U>::type jacobi_cs(T k, U theta);


   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&);

    }
}
# 18 "/usr/include/boost/math/special_functions/sign.hpp" 2 3 4
# 1 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 1 3 4
# 23 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 24 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 26 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 27 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 2 3 4
# 1 "/usr/include/boost/detail/endian.hpp" 1 3 4
# 28 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 2 3 4
# 81 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
namespace boost {
namespace math {
namespace detail {
# 92 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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 {};
# 125 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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;



};
# 177 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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); }
};
# 232 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 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); }
};
# 292 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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); }
};
# 318 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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 = 0x7fff0000;
    static const uint32_t flag = 0x00008000;
    static const uint32_t significand = 0x00007fff;

    typedef uint32_t bits;

    static void get_bits(long double x, uint32_t& a)
    {
        std::memcpy(&a, reinterpret_cast<const unsigned char*>(&x) + 6, 4);
    }

    static void set_bits(long double& x, uint32_t a)
    {
        std::memcpy(reinterpret_cast<unsigned char*>(&x) + 6, &a, 4);
    }
};
# 483 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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;
};
# 553 "/usr/include/boost/math/special_functions/detail/fp_traits.hpp" 3 4
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;
};



}
}
}
# 19 "/usr/include/boost/math/special_functions/sign.hpp" 2 3 4

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;
}

}
}
# 168 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/boost/math/special_functions/fpclassify.hpp" 1 3 4
# 17 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
# 1 "/usr/include/boost/math/tools/real_cast.hpp" 1 3 4
# 13 "/usr/include/boost/math/tools/real_cast.hpp" 3 4
namespace boost{ namespace math
{
  namespace tools
  {
    template <class To, class T>
    inline To real_cast(T t)
    {
       return static_cast<To>(t);
    }
  }
}
}
# 18 "/usr/include/boost/math/special_functions/fpclassify.hpp" 2 3 4
# 88 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
namespace boost{






namespace math_detail{

template <class T>
inline bool is_nan_helper(T t, const boost::true_type&)
{





   return (::std:: fpclassify(t) == (int)0);

}

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 0;
# 146 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
   T at = (t < T(0)) ? -t : t;







   if(at <= (std::numeric_limits<T>::max)())
   {
      if(at >= (std::numeric_limits<T>::min)())
         return 4;
      return (at != 0) ? 3 : 2;
   }
   else if(at > (std::numeric_limits<T>::max)())
      return 1;
   return 0;
}

template <class T>
inline int fpclassify_imp (T t, const generic_tag<false>&)
{
# 176 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
   ;

   return t == 0 ? 2 : 4;
}

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 2;
      else
         return 3;
   }

   if(a < traits::exponent) return 4;

   a &= traits::significand;
   if(a == 0) return 1;

   return 0;
}

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 2;
      else
         return 3;
   }

   if(a < traits::exponent) return 4;

   a &= traits::significand;
   traits::set_bits(x,a);
   if(x == 0) return 1;

   return 0;
}
# 244 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
}

template <class T>
inline int fpclassify (T t)
{
   typedef typename detail::fp_traits<T>::type traits;
   typedef typename traits::method method;
   typedef typename tools::promote_args<T>::type value_type;





   return detail::fpclassify_imp(static_cast<value_type>(t), method());

}
# 278 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
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;
    }
# 323 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
}

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;
   typedef typename tools::promote_args<T>::type value_type;
   return detail::isfinite_impl(static_cast<value_type>(x), method());
}
# 349 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
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);
    }
# 394 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
}

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;
   typedef typename tools::promote_args<T>::type value_type;
   return detail::isnormal_impl(static_cast<value_type>(x), method());
}
# 420 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
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;
    }
# 483 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
}

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;
   typedef typename tools::promote_args<T>::type value_type;
   return detail::isinf_impl(static_cast<value_type>(x), method());
}
# 509 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
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>
inline 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());
}
# 592 "/usr/include/boost/math/special_functions/fpclassify.hpp" 3 4
}
}
# 169 "/usr/include/boost/lexical_cast.hpp" 2 3 4

# 1 "/usr/include/boost/container/container_fwd.hpp" 1 3 4
# 24 "/usr/include/boost/container/container_fwd.hpp" 3 4
namespace boost{
namespace intrusive{

}}

namespace boost{ namespace container{ namespace container_detail{

namespace bi = boost::intrusive;

}}}
# 47 "/usr/include/boost/container/container_fwd.hpp" 3 4
namespace boost {
namespace container {


template <class T
         ,class Allocator = std::allocator<T> >
class vector;


template <class T
         ,class Allocator = std::allocator<T> >
class stable_vector;


template <class T
         ,class Allocator = std::allocator<T> >
class deque;


template <class T
         ,class Allocator = std::allocator<T> >
class list;


template <class T
         ,class Allocator = std::allocator<T> >
class slist;


template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<Key> >
class set;


template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<Key> >
class multiset;


template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<std::pair<const Key, T> > >
class map;


template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<std::pair<const Key, T> > >
class multimap;


template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<Key> >
class flat_set;


template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<Key> >
class flat_multiset;


template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<std::pair<Key, T> > >
class flat_map;


template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = std::allocator<std::pair<Key, T> > >
class flat_multimap;


template <class CharT
         ,class Traits = std::char_traits<CharT>
         ,class Allocator = std::allocator<CharT> >
class basic_string;



struct ordered_range_t
{};



struct ordered_unique_range_t
   : public ordered_range_t
{};



static const ordered_range_t ordered_range = ordered_range_t();



static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();



namespace detail_really_deep_namespace {



struct dummy
{
   dummy()
   {
      (void)ordered_range;
      (void)ordered_unique_range;
   }
};

}



}}
# 171 "/usr/include/boost/lexical_cast.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/cwchar" 1 3 4
# 39 "/usr/include/c++/4.8/cwchar" 3 4
       
# 40 "/usr/include/c++/4.8/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/usr/include/c++/4.8/cwchar" 2 3
# 173 "/usr/include/boost/lexical_cast.hpp" 2 3 4


namespace boost {

    namespace detail
    {

        template < typename T >
        struct is_char_or_wchar
        {
            typedef boost::type_traits::ice_or<
                    boost::is_same< T, char >::value,

                        boost::is_same< T, wchar_t >::value,







                    boost::is_same< T, unsigned char >::value,
                    boost::is_same< T, signed char >::value
            > result_type;

            static const bool value = (result_type::value);
        };
    }

    namespace detail
    {

        template < class Char >
        struct normalize_single_byte_char
        {
            typedef Char type;
        };

        template <>
        struct normalize_single_byte_char< signed char >
        {
            typedef char type;
        };

        template <>
        struct normalize_single_byte_char< unsigned char >
        {
            typedef char type;
        };
    }

    namespace detail
    {


        template < class T > struct deduce_character_type_later {};
    }

    namespace detail
    {



        template < typename Type >
        struct stream_char_common: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Type >::value,
            Type,
            boost::detail::deduce_character_type_later< Type >
        > {};

        template < typename Char >
        struct stream_char_common< Char* >: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< Char* >
        > {};

        template < typename Char >
        struct stream_char_common< const Char* >: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< const Char* >
        > {};

        template < typename Char >
        struct stream_char_common< boost::iterator_range< Char* > >: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
        > {};

        template < typename Char >
        struct stream_char_common< boost::iterator_range< const Char* > >: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
        > {};

        template < class Char, class Traits, class Alloc >
        struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
        {
            typedef Char type;
        };

        template < class Char, class Traits, class Alloc >
        struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
        {
            typedef Char type;
        };

        template < typename Char, std::size_t N >
        struct stream_char_common< boost::array< Char, N > >: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::array< Char, N > >
        > {};

        template < typename Char, std::size_t N >
        struct stream_char_common< boost::array< const Char, N > >: public boost::mpl::if_c<
            boost::detail::is_char_or_wchar< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::array< const Char, N > >
        > {};
# 320 "/usr/include/boost/lexical_cast.hpp" 3 4
    }

    namespace detail
    {





        template < class Char >
        struct deduce_source_char_impl
        {
            typedef typename boost::detail::normalize_single_byte_char< Char >::type type;
        };

        template < class T >
        struct deduce_source_char_impl< deduce_character_type_later< T > >
        {
            typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;






            typedef typename boost::mpl::if_c<
                result_t::value, char, wchar_t
            >::type type;

            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value)) == 0 ? false : true) >)> boost_static_assert_typedef_350
                                                                                  ;

        };
    }

    namespace detail
    {





        template < class Char >
        struct deduce_target_char_impl
        {
            typedef typename normalize_single_byte_char< Char >::type type;
        };

        template < class T >
        struct deduce_target_char_impl< deduce_character_type_later<T> >
        {
            typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;






            typedef typename boost::mpl::if_c<
                result_t::value, char, wchar_t
            >::type type;

            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value)) == 0 ? false : true) >)> boost_static_assert_typedef_383
                                                                                  ;

        };
    }

    namespace detail
    {
# 405 "/usr/include/boost/lexical_cast.hpp" 3 4
        template < class T >
        struct deduce_target_char
        {
            typedef typename stream_char_common< T >::type stage1_type;
            typedef typename deduce_target_char_impl< stage1_type >::type stage2_type;

            typedef stage2_type type;
        };

        template < class T >
        struct deduce_source_char
        {
            typedef typename stream_char_common< T >::type stage1_type;
            typedef typename deduce_source_char_impl< stage1_type >::type stage2_type;

            typedef stage2_type type;
        };
    }

    namespace detail
    {


        template < class Char, class Target, class Source >
        struct deduce_char_traits
        {
            typedef std::char_traits< Char > type;
        };

        template < class Char, class Traits, class Alloc, class Source >
        struct deduce_char_traits< Char
                                 , std::basic_string< Char, Traits, Alloc >
                                 , Source
                                 >
        {
            typedef Traits type;
        };

        template < class Char, class Target, class Traits, class Alloc >
        struct deduce_char_traits< Char
                                 , Target
                                 , std::basic_string< Char, Traits, Alloc >
                                 >
        {
            typedef Traits type;
        };

        template < class Char, class Traits, class Alloc, class Source >
        struct deduce_char_traits< Char
                                 , boost::container::basic_string< Char, Traits, Alloc >
                                 , Source
                                 >
        {
            typedef Traits type;
        };

        template < class Char, class Target, class Traits, class Alloc >
        struct deduce_char_traits< Char
                                 , Target
                                 , boost::container::basic_string< Char, Traits, Alloc >
                                 >
        {
            typedef Traits type;
        };

        template < class Char, class Traits, class Alloc1, class Alloc2 >
        struct deduce_char_traits< Char
                                 , std::basic_string< Char, Traits, Alloc1 >
                                 , std::basic_string< Char, Traits, Alloc2 >
                                 >
        {
            typedef Traits type;
        };

        template<class Char, class Traits, class Alloc1, class Alloc2>
        struct deduce_char_traits< Char
                                 , boost::container::basic_string< Char, Traits, Alloc1 >
                                 , boost::container::basic_string< Char, Traits, Alloc2 >
                                 >
        {
            typedef Traits type;
        };

        template < class Char, class Traits, class Alloc1, class Alloc2 >
        struct deduce_char_traits< Char
                                 , boost::container::basic_string< Char, Traits, Alloc1 >
                                 , std::basic_string< Char, Traits, Alloc2 >
                                 >
        {
            typedef Traits type;
        };

        template < class Char, class Traits, class Alloc1, class Alloc2 >
        struct deduce_char_traits< Char
                                 , std::basic_string< Char, Traits, Alloc1 >
                                 , boost::container::basic_string< Char, Traits, Alloc2 >
                                 >
        {
            typedef Traits type;
        };
    }

    namespace detail
    {
        template<class T>
        struct array_to_pointer_decay
        {
            typedef T type;
        };

        template<class T, std::size_t N>
        struct array_to_pointer_decay<T[N]>
        {
            typedef const T * type;
        };
    }

    namespace detail
    {



        template <typename Float, typename Char>
        struct is_this_float_conversion_optimized
        {
            typedef boost::type_traits::ice_and<
                boost::is_float<Float>::value,

                boost::type_traits::ice_or<
                    boost::type_traits::ice_eq<sizeof(Char), sizeof(char) >::value,
                    boost::is_same<Char, wchar_t>::value
                >::value



            > result_type;

            static const bool value = (result_type::value);
        };
    }

    namespace detail
    {

        template< class Source
                >
        struct lcast_src_length
        {
            static const std::size_t value = 1;


            static void check_coverage() {}
        };
# 572 "/usr/include/boost/lexical_cast.hpp" 3 4
        template<class Source>
        struct lcast_src_length_integral
        {

            static const std::size_t value = std::numeric_limits<Source>::is_signed + std::numeric_limits<Source>::is_specialized + std::numeric_limits<Source>::digits10 * 2



               ;




        };






        template<> struct lcast_src_length<short> : lcast_src_length_integral<short> { static void check_coverage() {} };
        template<> struct lcast_src_length<unsigned short> : lcast_src_length_integral<unsigned short> { static void check_coverage() {} };
        template<> struct lcast_src_length<int> : lcast_src_length_integral<int> { static void check_coverage() {} };
        template<> struct lcast_src_length<unsigned int> : lcast_src_length_integral<unsigned int> { static void check_coverage() {} };
        template<> struct lcast_src_length<long> : lcast_src_length_integral<long> { static void check_coverage() {} };
        template<> struct lcast_src_length<unsigned long> : lcast_src_length_integral<unsigned long> { static void check_coverage() {} };

        template<> struct lcast_src_length<boost::ulong_long_type> : lcast_src_length_integral<boost::ulong_long_type> { static void check_coverage() {} };
        template<> struct lcast_src_length<boost::long_long_type> : lcast_src_length_integral<boost::long_long_type> { static void check_coverage() {} };
# 619 "/usr/include/boost/lexical_cast.hpp" 3 4
        template<class Source>
        struct lcast_src_length_floating
        {
            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((std::numeric_limits<Source>::max_exponent10 <= 999999L && std::numeric_limits<Source>::min_exponent10 >= -999999L) == 0 ? false : true) >)> boost_static_assert_typedef_625


                 ;
            static const std::size_t value = 5 + lcast_precision<Source>::value + 6

                 ;
        };

        template<>
        struct lcast_src_length<float>
          : lcast_src_length_floating<float>
        {
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<double>
          : lcast_src_length_floating<double>
        {
            static void check_coverage() {}
        };

        template<>
        struct lcast_src_length<long double>
          : lcast_src_length_floating<long double>
        {
            static void check_coverage() {}
        };


    }

    namespace detail
    {
        template <class Source, class Target>
        struct lexical_cast_stream_traits {
            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
            typedef typename boost::remove_cv<src>::type no_cv_src;

            typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
            typedef typename deduce_src_char_metafunc::type src_char_t;
            typedef typename boost::detail::deduce_target_char<Target>::type target_char_t;

            typedef typename boost::detail::widest_char<
                target_char_t, src_char_t
            >::type char_type;
# 681 "/usr/include/boost/lexical_cast.hpp" 3 4
            typedef typename boost::detail::deduce_char_traits<
                char_type, Target, no_cv_src
            >::type traits;

            typedef boost::type_traits::ice_and<
                boost::is_same<char, src_char_t>::value,
                boost::type_traits::ice_ne<sizeof(char), sizeof(target_char_t) >::value,
                boost::type_traits::ice_not<
                    boost::detail::is_char_or_wchar<no_cv_src>::value
                >::value
            > is_string_widening_required_t;

            typedef boost::type_traits::ice_not< boost::type_traits::ice_or<
                boost::is_integral<no_cv_src>::value,
                boost::detail::is_this_float_conversion_optimized<no_cv_src, char_type >::value,
                boost::detail::is_char_or_wchar<
                    typename deduce_src_char_metafunc::stage1_type
                >::value
            >::value > is_source_input_not_optimized_t;



            static const bool requires_stringbuf = (boost::type_traits::ice_or< is_string_widening_required_t::value, is_source_input_not_optimized_t::value >::value)



             ;

            typedef boost::detail::lcast_src_length<no_cv_src> len_t;
        };
    }

    namespace detail
    {
        template < typename Char > struct lcast_char_constants;

        template<>
        struct lcast_char_constants<char>
        {
            static const char zero = '0';
            static const char minus = '-';
            static const char plus = '+';
            static const char lowercase_e = 'e';
            static const char capital_e = 'E';
            static const char c_decimal_separator = '.';
        };


        template<>
        struct lcast_char_constants<wchar_t>
        {
            static const wchar_t zero = L'0';
            static const wchar_t minus = L'-';
            static const wchar_t plus = L'+';
            static const wchar_t lowercase_e = L'e';
            static const wchar_t capital_e = L'E';
            static const wchar_t c_decimal_separator = L'.';
        };
# 766 "/usr/include/boost/lexical_cast.hpp" 3 4
    }

    namespace detail
    {
        template<class T>
        inline
        typename make_unsigned<T>::type lcast_to_unsigned(T value)
        {
            typedef typename boost::make_unsigned<T>::type result_type;
            return static_cast<result_type>(
                value < 0 ? 0u - static_cast<result_type>(value) : value
            );
        }
    }

    namespace detail
    {
        template<class Traits, class T, class CharT>
        CharT* lcast_put_unsigned(const T n_param, CharT* finish)
        {

            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!std::numeric_limits<T>::is_signed) == 0 ? false : true) >)> boost_static_assert_typedef_787;


            typedef typename Traits::int_type int_type;
            CharT const czero = lcast_char_constants<CharT>::zero;
            int_type const zero = Traits::to_int_type(czero);
            typename boost::mpl::if_c<
                    (sizeof(int_type) > sizeof(T))
                    , int_type
                    , T
            >::type n = n_param;


            std::locale loc;
            if (loc != std::locale::classic()) {
                typedef std::numpunct<CharT> numpunct;
                numpunct const& np = std::use_facet< numpunct >(loc);
                std::string const grouping = np.grouping();
                std::string::size_type const grouping_size = grouping.size();

                if ( grouping_size && grouping[0] > 0 )
                {



                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((std::numeric_limits<T>::digits10 < 127) == 0 ? false : true) >)> boost_static_assert_typedef_812;

                    CharT thousands_sep = np.thousands_sep();
                    std::string::size_type group = 0;
                    char last_grp_size = grouping[0];
                    char left = last_grp_size;

                    do
                    {
                        if(left == 0)
                        {
                            ++group;
                            if(group < grouping_size)
                            {
                                char const grp_size = grouping[group];
                                last_grp_size = grp_size <= 0 ? 127 : grp_size;
                            }

                            left = last_grp_size;
                            --finish;
                            Traits::assign(*finish, thousands_sep);
                        }

                        --left;

                        --finish;
                        int_type const digit = static_cast<int_type>(n % 10U);
                        Traits::assign(*finish, Traits::to_char_type(zero + digit));
                        n /= 10;
                    } while(n);
                    return finish;
                }
            }

            {
                do
                {
                    --finish;
                    int_type const digit = static_cast<int_type>(n % 10U);
                    Traits::assign(*finish, Traits::to_char_type(zero + digit));
                    n /= 10;
                } while(n);
            }

            return finish;
        }
    }

    namespace detail
    {
        template<class Traits, class T, class CharT>
        inline bool lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end)
        {

            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!std::numeric_limits<T>::is_signed) == 0 ? false : true) >)> boost_static_assert_typedef_866;

            typedef typename Traits::int_type int_type;
            CharT const czero = lcast_char_constants<CharT>::zero;
            --end;
            value = 0;

            if (begin > end || *end < czero || *end >= czero + 10)
                return false;
            value = *end - czero;
            --end;
            T multiplier = 1;
            bool multiplier_overflowed = false;


            std::locale loc;
            if (loc != std::locale::classic()) {
                typedef std::numpunct<CharT> numpunct;
                numpunct const& np = std::use_facet< numpunct >(loc);
                std::string const& grouping = np.grouping();
                std::string::size_type const grouping_size = grouping.size();




                if (grouping_size && grouping[0] > 0)
                {
                    unsigned char current_grouping = 0;
                    CharT const thousands_sep = np.thousands_sep();
                    char remained = grouping[current_grouping] - 1;
                    bool shall_we_return = true;

                    for(;end>=begin; --end)
                    {
                        if (remained) {
                            T const multiplier_10 = multiplier * 10;
                            if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;

                            T const dig_value = *end - czero;
                            T const new_sub_value = multiplier_10 * dig_value;

                            if (*end < czero || *end >= czero + 10

                                    || (dig_value && new_sub_value / dig_value != multiplier_10)
                                    || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
                                    || (multiplier_overflowed && dig_value)
                                    )
                                return false;

                            value += new_sub_value;
                            multiplier *= 10;
                            --remained;
                        } else {
                            if ( !Traits::eq(*end, thousands_sep) )
                            {
# 932 "/usr/include/boost/lexical_cast.hpp" 3 4
                                shall_we_return = false;
                                break;
                            } else {
                                if ( begin == end ) return false;
                                if (current_grouping < grouping_size-1 ) ++current_grouping;
                                remained = grouping[current_grouping];
                            }
                        }
                    }

                    if (shall_we_return) return true;
                }
            }

            {
                while ( begin <= end )
                {
                    T const multiplier_10 = multiplier * 10;
                    if (multiplier_10 / 10 != multiplier) multiplier_overflowed = true;

                    T const dig_value = *end - czero;
                    T const new_sub_value = multiplier_10 * dig_value;

                    if (*end < czero || *end >= czero + 10

                            || (dig_value && new_sub_value / dig_value != multiplier_10)
                            || static_cast<T>((std::numeric_limits<T>::max)()-new_sub_value) < value
                            || (multiplier_overflowed && dig_value)
                            )
                        return false;

                    value += new_sub_value;
                    multiplier *= 10;
                    --end;
                }
            }
            return true;
        }
    }

    namespace detail
    {
        template <class CharT>
        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) {
            for( unsigned int i=0; i < len; ++i ) {
                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
            }

            return true;
        }


        template <class CharT, class T>
        inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
            , const CharT* lc_NAN, const CharT* lc_nan
            , const CharT* lc_INFINITY, const CharT* lc_infinity
            , const CharT opening_brace, const CharT closing_brace)
        {
            using namespace std;
            if (begin == end) return false;
            const CharT minus = lcast_char_constants<CharT>::minus;
            const CharT plus = lcast_char_constants<CharT>::plus;
            const int inifinity_size = 8;

            bool has_minus = false;

            if( *begin == minus)
            {
                ++ begin;
                has_minus = true;
            }
            else if( *begin == plus ) ++begin;

            if( end-begin < 3 ) return false;
            if( lc_iequal(begin, lc_nan, lc_NAN, 3) )
            {
                begin += 3;
                if (end != begin)
                {
                    if(end-begin<2) return false;
                    -- end;
                    if( *begin != opening_brace || *end != closing_brace) return false;
                }

                if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
                else value = (boost::math::changesign) (std::numeric_limits<T>::quiet_NaN());
                return true;
            } else
            if ((
                  end-begin==3
                  &&
                  lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
                )
                ||
                (
                  end-begin==inifinity_size
                  &&
                  lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
                )
             )
            {
                if( !has_minus ) value = std::numeric_limits<T>::infinity();
                else value = (boost::math::changesign) (std::numeric_limits<T>::infinity());
                return true;
            }

            return false;
        }

        template <class CharT, class T>
        bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
                         , const CharT* lc_nan
                         , const CharT* lc_infinity)
        {
            using namespace std;
            const CharT minus = lcast_char_constants<CharT>::minus;
            if ( (boost::math::isnan)(value) )
            {
                if ( (boost::math::signbit)(value) )
                {
                    *begin = minus;
                    ++ begin;
                }

                memcpy(begin, lc_nan, 3 * sizeof(CharT));
                end = begin + 3;
                return true;
            } else if ( (boost::math::isinf)(value) )
            {
                if ( (boost::math::signbit)(value) )
                {
                    *begin = minus;
                    ++ begin;
                }

                memcpy(begin, lc_infinity, 3 * sizeof(CharT));
                end = begin + 3;
                return true;
            }

            return false;
        }



        template <class T>
        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value)
        {
            return parse_inf_nan_impl(begin, end, value
                               , L"NAN", L"nan"
                               , L"INFINITY", L"infinity"
                               , L'(', L')');
        }

        template <class T>
        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value)
        {
            return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
        }
# 1126 "/usr/include/boost/lexical_cast.hpp" 3 4
        template <class CharT, class T>
        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value)
        {
            return parse_inf_nan_impl(begin, end, value
                               , "NAN", "nan"
                               , "INFINITY", "infinity"
                               , '(', ')');
        }

        template <class CharT, class T>
        bool put_inf_nan(CharT* begin, CharT*& end, const T& value)
        {
            return put_inf_nan_impl(begin, end, value, "nan", "infinity");
        }
    }


    namespace detail
    {
        template <class T>
        struct mantissa_holder_type
        {

        };

        template <>
        struct mantissa_holder_type<float>
        {
            typedef unsigned int type;
        };

        template <>
        struct mantissa_holder_type<double>
        {

            typedef boost::ulong_long_type type;



        };

        template<class Traits, class T, class CharT>
        inline bool lcast_ret_float(T& value, const CharT* begin, const CharT* end)
        {


            std::locale loc;
            typedef std::numpunct<CharT> numpunct;
            numpunct const& np = std::use_facet< numpunct >(loc);
            std::string const grouping(
                    (loc == std::locale::classic())
                    ? std::string()
                    : np.grouping()
            );
            std::string::size_type const grouping_size = grouping.size();
            CharT const thousands_sep = grouping_size ? np.thousands_sep() : 0;
            CharT const decimal_point = np.decimal_point();
            bool found_grouping = false;
            std::string::size_type last_grouping_pos = grouping_size - 1;




            CharT const czero = lcast_char_constants<CharT>::zero;
            CharT const minus = lcast_char_constants<CharT>::minus;
            CharT const plus = lcast_char_constants<CharT>::plus;
            CharT const capital_e = lcast_char_constants<CharT>::capital_e;
            CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;

            value = static_cast<T>(0);

            if (parse_inf_nan(begin, end, value)) return true;

            typedef typename Traits::int_type int_type;
            typedef typename mantissa_holder_type<T>::type mantissa_type;
            int_type const zero = Traits::to_int_type(czero);
            if (begin == end) return false;


            bool has_minus = false;
            if (Traits::eq(*begin, minus) ) {
                ++ begin;
                has_minus = true;
                if (begin == end) return false;
            } else if (Traits::eq(*begin, plus) ) {
                ++begin;
                if (begin == end) return false;
            }

            bool found_decimal = false;
            bool found_number_before_exp = false;
            int pow_of_10 = 0;
            mantissa_type mantissa=0;
            bool is_mantissa_full = false;

            char length_since_last_delim = 0;

            while ( begin != end )
            {
                if (found_decimal) {


                    mantissa_type tmp_mantissa = mantissa * 10u;
                    if (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) break;
                    if ( *begin < czero || *begin >= czero + 10 ) return false;
                    if ( is_mantissa_full
                            || tmp_mantissa / 10u != mantissa
                            || (std::numeric_limits<mantissa_type>::max)()-(*begin - zero) < tmp_mantissa
                            ) {
                        is_mantissa_full = true;
                        ++ begin;
                        continue;
                    }

                    -- pow_of_10;
                    mantissa = tmp_mantissa;
                    mantissa += *begin - zero;

                    found_number_before_exp = true;
                } else {

                    if (*begin >= czero && *begin < czero + 10) {




                        mantissa_type tmp_mantissa = mantissa * 10u;
                        if( !is_mantissa_full
                                && tmp_mantissa / 10u == mantissa
                                && (std::numeric_limits<mantissa_type>::max)()-(*begin - zero) >= tmp_mantissa
                            )
                        {
                            mantissa = tmp_mantissa;
                            mantissa += *begin - zero;
                        } else
                        {
                            is_mantissa_full = true;
                            ++ pow_of_10;
                        }

                        found_number_before_exp = true;
                        ++ length_since_last_delim;
                    } else if (Traits::eq(*begin, decimal_point) || Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) {
# 1277 "/usr/include/boost/lexical_cast.hpp" 3 4
                        if( grouping_size && found_grouping
                            && (
                                   length_since_last_delim != grouping[0]
                                   || last_grouping_pos>1
                                   || (last_grouping_pos==0 && grouping_size>1)
                                )
                           ) return false;


                        if(Traits::eq(*begin, decimal_point)) {
                            ++ begin;
                            found_decimal = true;
                            if (!found_number_before_exp && begin==end) return false;
                            continue;
                        }else {
                            if (!found_number_before_exp) return false;
                            break;
                        }
                    }

                    else if (grouping_size && Traits::eq(*begin, thousands_sep)){
                        if(found_grouping)
                        {




                            if (length_since_last_delim != grouping[last_grouping_pos] )
                            {
                                if (!last_grouping_pos) return false;
                                else
                                {
                                    -- last_grouping_pos;
                                    if (length_since_last_delim != grouping[last_grouping_pos]) return false;
                                }
                            } else

                                if (grouping_size>1u && last_grouping_pos+1<grouping_size) return false;

                        } else {

                            if (!length_since_last_delim) return false;

                            found_grouping = true;
                            if (length_since_last_delim > grouping[last_grouping_pos] ) return false;
                        }

                        length_since_last_delim = 0;
                        ++ begin;


                        if (begin == end) return false;
                        continue;
                    }

                    else return false;
                }

                ++begin;
            }


            if ( begin != end && (Traits::eq(*begin, lowercase_e) || Traits::eq(*begin, capital_e)) ) {
                ++ begin;
                if ( begin == end ) return false;

                bool exp_has_minus = false;
                if(Traits::eq(*begin, minus)) {
                    exp_has_minus = true;
                    ++ begin;
                    if ( begin == end ) return false;
                } else if (Traits::eq(*begin, plus)) {
                    ++ begin;
                    if ( begin == end ) return false;
                }

                int exp_pow_of_10 = 0;
                while ( begin != end )
                {
                    if ( *begin < czero
                            || *begin >= czero + 10
                            || exp_pow_of_10 * 10 < exp_pow_of_10)
                        return false;

                    exp_pow_of_10 *= 10;
                    exp_pow_of_10 += *begin - zero;
                    ++ begin;
                };

                if ( exp_pow_of_10 ) {

                    if ( exp_has_minus ) {
                        pow_of_10 -= exp_pow_of_10;
                    } else {
                        pow_of_10 += exp_pow_of_10;
                    }
                }
            }




            long double result = std::pow(10.0L, pow_of_10) * mantissa;
            value = static_cast<T>( has_minus ? (boost::math::changesign)(result) : result);

            if ( (boost::math::isinf)(value) || (boost::math::isnan)(value) ) return false;

            return true;
        }
    }

    namespace detail
    {
        template< class BufferType, class CharT >
        class stl_buf_unlocker: public BufferType{
        public:
            typedef BufferType base_class;

            using base_class::pptr;
            using base_class::pbase;
            using base_class::setg;
            using base_class::setp;






        };
    }

    namespace detail
    {
        struct do_not_construct_out_stream_t{};
    }

    namespace detail
    {

        template< class CharT
                , class Traits
                , bool RequiresStringbuffer
                >
        class lexical_stream_limited_src
        {
# 1430 "/usr/include/boost/lexical_cast.hpp" 3 4
            typedef std::basic_ostringstream<CharT, Traits> out_stream_t;
            typedef stl_buf_unlocker<std::basic_stringbuf<CharT, Traits>, CharT> unlocked_but_t;

            typedef typename boost::mpl::if_c<
                RequiresStringbuffer,
                out_stream_t,
                do_not_construct_out_stream_t
            >::type deduced_out_stream_t;


            CharT* start;
            CharT* finish;
            deduced_out_stream_t out_stream;

        public:
            lexical_stream_limited_src(CharT* sta, CharT* fin)
              : start(sta)
              , finish(fin)
            {}

        private:

            lexical_stream_limited_src(lexical_stream_limited_src const&);
            void operator=(lexical_stream_limited_src const&);


            bool shl_char(CharT ch)
            {
                Traits::assign(*start, ch);
                finish = start + 1;
                return true;
            }


            template <class T>
            bool shl_char(T ch)
            {
                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( sizeof(T) <= sizeof(CharT))) == 0 ? false : true) >)> boost_static_assert_typedef_1469

                                                 ;

                std::locale loc;
                CharT const w = std::use_facet< std::ctype<CharT> >(loc).widen(ch);



                Traits::assign(*start, w);
                finish = start + 1;
                return true;
            }


            bool shl_char_array(CharT const* str)
            {
                start = const_cast<CharT*>(str);
                finish = start + Traits::length(str);
                return true;
            }

            template <class T>
            bool shl_char_array(T const* str)
            {
                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( sizeof(T) <= sizeof(CharT))) == 0 ? false : true) >)> boost_static_assert_typedef_1494

                                                 ;
                return shl_input_streamable(str);
            }

            bool shl_char_array_limited(CharT const* str, std::size_t max_size)
            {
                start = const_cast<CharT*>(str);
                finish = std::find(start, start + max_size, Traits::to_char_type(0));
                return true;
            }

            template<typename InputStreamable>
            bool shl_input_streamable(InputStreamable& input)
            {





                bool const result = !(out_stream << input).fail();
                const unlocked_but_t* const p
                        = static_cast<unlocked_but_t*>(out_stream.rdbuf()) ;
                start = p->pbase();
                finish = p->pptr();
                return result;
            }

            template <class T>
            inline bool shl_signed(T n)
            {
                start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
                if(n < 0)
                {
                    --start;
                    CharT const minus = lcast_char_constants<CharT>::minus;
                    Traits::assign(*start, minus);
                }
                return true;
            }

            template <class T, class SomeCharT>
            bool shl_real_type(const T& val, SomeCharT* begin, SomeCharT*& end)
            {
                if (put_inf_nan(begin, end, val)) return true;
                lcast_set_precision(out_stream, &val);
                return shl_input_streamable(val);
            }

            static bool shl_real_type(float val, char* begin, char*& end)
            { using namespace std;
                if (put_inf_nan(begin, end, val)) return true;
                const double val_as_double = val;
                end = begin +



                    sprintf(begin,

                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
                return end > begin;
            }

            static bool shl_real_type(double val, char* begin, char*& end)
            { using namespace std;
                if (put_inf_nan(begin, end, val)) return true;
                end = begin +



                    sprintf(begin,

                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
                return end > begin;
            }


            static bool shl_real_type(long double val, char* begin, char*& end)
            { using namespace std;
                if (put_inf_nan(begin, end, val)) return true;
                end = begin +



                    sprintf(begin,

                    "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
                return end > begin;
            }




            static bool shl_real_type(float val, wchar_t* begin, wchar_t*& end)
            { using namespace std;
                if (put_inf_nan(begin, end, val)) return true;
                const double val_as_double = val;
                end = begin + swprintf(begin, end-begin,
                                       L"%.*g",
                                       static_cast<int>(boost::detail::lcast_get_precision<float >()),
                                       val_as_double );
                return end > begin;
            }

            static bool shl_real_type(double val, wchar_t* begin, wchar_t*& end)
            { using namespace std;
                if (put_inf_nan(begin, end, val)) return true;
                end = begin + swprintf(begin, end-begin,
                                          L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
                return end > begin;
            }

            static bool shl_real_type(long double val, wchar_t* begin, wchar_t*& end)
            { using namespace std;
                if (put_inf_nan(begin, end, val)) return true;
                end = begin + swprintf(begin, end-begin,
                                          L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
                return end > begin;
            }



        public:
            template<class Alloc>
            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str)
            {
                start = const_cast<CharT*>(str.data());
                finish = start + str.length();
                return true;
            }

            template<class Alloc>
            bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str)
            {
                start = const_cast<CharT*>(str.data());
                finish = start + str.length();
                return true;
            }

            bool operator<<(bool value)
            {
                CharT const czero = lcast_char_constants<CharT>::zero;
                Traits::assign(*start, Traits::to_char_type(czero + value));
                finish = start + 1;
                return true;
            }

            bool operator<<(const iterator_range<CharT*>& rng)
            {
                start = rng.begin();
                finish = rng.end();
                return true;
            }

            bool operator<<(const iterator_range<const CharT*>& rng)
            {
                start = const_cast<CharT*>(rng.begin());
                finish = const_cast<CharT*>(rng.end());
                return true;
            }

            bool operator<<(const iterator_range<const signed char*>& rng)
            {
                return (*this) << iterator_range<char*>(
                    const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
                    const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
                );
            }

            bool operator<<(const iterator_range<const unsigned char*>& rng)
            {
                return (*this) << iterator_range<char*>(
                    const_cast<char*>(reinterpret_cast<const char*>(rng.begin())),
                    const_cast<char*>(reinterpret_cast<const char*>(rng.end()))
                );
            }

            bool operator<<(const iterator_range<signed char*>& rng)
            {
                return (*this) << iterator_range<char*>(
                    reinterpret_cast<char*>(rng.begin()),
                    reinterpret_cast<char*>(rng.end())
                );
            }

            bool operator<<(const iterator_range<unsigned char*>& rng)
            {
                return (*this) << iterator_range<char*>(
                    reinterpret_cast<char*>(rng.begin()),
                    reinterpret_cast<char*>(rng.end())
                );
            }

            bool operator<<(char ch) { return shl_char(ch); }
            bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
            bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }

            bool operator<<(wchar_t const* str) { return shl_char_array(str); }
            bool operator<<(wchar_t * str) { return shl_char_array(str); }

            bool operator<<(wchar_t ch) { return shl_char(ch); }
# 1706 "/usr/include/boost/lexical_cast.hpp" 3 4
            bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
            bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
            bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
            bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
            bool operator<<(char const* str) { return shl_char_array(str); }
            bool operator<<(char* str) { return shl_char_array(str); }
            bool operator<<(short n) { return shl_signed(n); }
            bool operator<<(int n) { return shl_signed(n); }
            bool operator<<(long n) { return shl_signed(n); }
            bool operator<<(unsigned short n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
            bool operator<<(unsigned int n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
            bool operator<<(unsigned long n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }


            bool operator<<(boost::ulong_long_type n) { start = lcast_put_unsigned<Traits>(n, finish); return true; }
            bool operator<<(boost::long_long_type n) { return shl_signed(n); }




            bool operator<<(float val) { return shl_real_type(val, start, finish); }
            bool operator<<(double val) { return shl_real_type(val, start, finish); }
            bool operator<<(long double val) {

                return shl_real_type(val, start, finish);



            }

            template <std::size_t N>
            bool operator<<(boost::array<CharT, N> const& input)
            { return shl_char_array_limited(input.begin(), N); }

            template <std::size_t N>
            bool operator<<(boost::array<unsigned char, N> const& input)
            { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }

            template <std::size_t N>
            bool operator<<(boost::array<signed char, N> const& input)
            { return ((*this) << reinterpret_cast<boost::array<char, N> const& >(input)); }

            template <std::size_t N>
            bool operator<<(boost::array<const CharT, N> const& input)
            { return shl_char_array_limited(input.begin(), N); }

            template <std::size_t N>
            bool operator<<(boost::array<const unsigned char, N> const& input)
            { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }

            template <std::size_t N>
            bool operator<<(boost::array<const signed char, N> const& input)
            { return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input)); }
# 1792 "/usr/include/boost/lexical_cast.hpp" 3 4
            template <class InStreamable>
            bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }


        private:

            template <typename Type>
            bool shr_unsigned(Type& output)
            {
                if (start == finish) return false;
                CharT const minus = lcast_char_constants<CharT>::minus;
                CharT const plus = lcast_char_constants<CharT>::plus;
                bool has_minus = false;


                if ( Traits::eq(minus,*start) )
                {
                    ++start;
                    has_minus = true;
                } else if ( Traits::eq( plus, *start ) )
                {
                    ++start;
                }

                bool const succeed = lcast_ret_unsigned<Traits>(output, start, finish);

                if (has_minus) {
                    output = static_cast<Type>(0u - output);
                }

                return succeed;
            }

            template <typename Type>
            bool shr_signed(Type& output)
            {
                if (start == finish) return false;
                CharT const minus = lcast_char_constants<CharT>::minus;
                CharT const plus = lcast_char_constants<CharT>::plus;
                typedef typename make_unsigned<Type>::type utype;
                utype out_tmp =0;
                bool has_minus = false;


                if ( Traits::eq(minus,*start) )
                {
                    ++start;
                    has_minus = true;
                } else if ( Traits::eq(plus, *start) )
                {
                    ++start;
                }

                bool succeed = lcast_ret_unsigned<Traits>(out_tmp, start, finish);
                if (has_minus) {
                    utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
                    succeed = succeed && out_tmp<=comp_val;
                    output = static_cast<Type>(0u - out_tmp);
                } else {
                    utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
                    succeed = succeed && out_tmp<=comp_val;
                    output = out_tmp;
                }
                return succeed;
            }

            template<typename InputStreamable>
            bool shr_using_base_class(InputStreamable& output)
            {





                if(is_pointer<InputStreamable>::value)
                    return false;
# 1880 "/usr/include/boost/lexical_cast.hpp" 3 4
                std::basic_istringstream<CharT, Traits> stream;

                static_cast<unlocked_but_t*>(stream.rdbuf())
                        ->setg(start, start, finish);

                stream.unsetf(std::ios::skipws);
                lcast_set_precision(stream, static_cast<InputStreamable*>(0));



                return stream >> output &&
                    stream.get() ==







                Traits::eof();

            }

            template<class T>
            inline bool shr_xchar(T& output)
            {
                typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( sizeof(CharT) == sizeof(T) )) == 0 ? false : true) >)> boost_static_assert_typedef_1908

                                                 ;
                bool const ok = (finish - start == 1);
                if (ok) {
                    CharT out;
                    Traits::assign(out, *start);
                    output = static_cast<T>(out);
                }
                return ok;
            }


            public:
            bool operator>>(unsigned short& output) { return shr_unsigned(output); }
            bool operator>>(unsigned int& output) { return shr_unsigned(output); }
            bool operator>>(unsigned long int& output) { return shr_unsigned(output); }
            bool operator>>(short& output) { return shr_signed(output); }
            bool operator>>(int& output) { return shr_signed(output); }
            bool operator>>(long int& output) { return shr_signed(output); }

            bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); }
            bool operator>>(boost::long_long_type& output) { return shr_signed(output); }




            bool operator>>(char& output) { return shr_xchar(output); }
            bool operator>>(unsigned char& output) { return shr_xchar(output); }
            bool operator>>(signed char& output) { return shr_xchar(output); }

            bool operator>>(wchar_t& output) { return shr_xchar(output); }







            template<class Alloc>
            bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }

            template<class Alloc>
            bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) { str.assign(start, finish); return true; }


    private:
            template <std::size_t N, class ArrayT>
            bool shr_std_array(ArrayT& output)
            {
                using namespace std;
                const std::size_t size = finish - start;
                if (size > N - 1) {
                    return false;
                }

                memcpy(&output[0], start, size * sizeof(CharT));
                output[size] = Traits::to_char_type(0);
                return true;
            }

    public:

            template <std::size_t N>
            bool operator>>(boost::array<CharT, N>& output)
            {
                return shr_std_array<N>(output);
            }

            template <std::size_t N>
            bool operator>>(boost::array<unsigned char, N>& output)
            {
                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
            }

            template <std::size_t N>
            bool operator>>(boost::array<signed char, N>& output)
            {
                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
            }
# 2013 "/usr/include/boost/lexical_cast.hpp" 3 4
            bool operator>>(bool& output)
            {
                CharT const zero = lcast_char_constants<CharT>::zero;
                CharT const plus = lcast_char_constants<CharT>::plus;
                CharT const minus = lcast_char_constants<CharT>::minus;

                switch(finish-start)
                {
                    case 1:
                        output = Traits::eq(start[0], zero+1);
                        return output || Traits::eq(start[0], zero );
                    case 2:
                        if ( Traits::eq( plus, *start) )
                        {
                            ++start;
                            output = Traits::eq(start[0], zero +1);
                            return output || Traits::eq(start[0], zero );
                        } else
                        {
                            output = false;
                            return Traits::eq( minus, *start)
                                && Traits::eq( zero, start[1]);
                        }
                    default:
                        output = false;
                        return false;
                }
            }

            bool operator>>(float& output) { return lcast_ret_float<Traits>(output,start,finish); }

        private:

            template <class T>
            bool float_types_converter_internal(T& output, int ) {
                if (parse_inf_nan(start, finish, output)) return true;
                bool return_value = shr_using_base_class(output);







                CharT const minus = lcast_char_constants<CharT>::minus;
                CharT const plus = lcast_char_constants<CharT>::plus;
                CharT const capital_e = lcast_char_constants<CharT>::capital_e;
                CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
                if ( return_value &&
                     (
                        Traits::eq(*(finish-1), lowercase_e)
                        || Traits::eq(*(finish-1), capital_e)
                        || Traits::eq(*(finish-1), minus)
                        || Traits::eq(*(finish-1), plus)
                     )
                ) return false;

                return return_value;
            }


            bool float_types_converter_internal(double& output,char ) {
                return lcast_ret_float<Traits>(output,start,finish);
            }
        public:

            bool operator>>(double& output)
            {






                boost::mpl::if_c<

                    boost::type_traits::ice_eq< sizeof(double), sizeof(long double) >::value,



                    int,
                    char
                >::type tag = 0;

                return float_types_converter_internal(output, tag);
            }

            bool operator>>(long double& output)
            {
                int tag = 0;
                return float_types_converter_internal(output, tag);
            }



            template<typename InputStreamable>
            bool operator>>(InputStreamable& output) { return shr_using_base_class(output); }
        };
    }

    namespace detail
    {
        template<typename T>
        struct is_stdstring
        {
            static const bool value = false;
        };

        template<typename CharT, typename Traits, typename Alloc>
        struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
        {
            static const bool value = true;
        };

        template<typename CharT, typename Traits, typename Alloc>
        struct is_stdstring< boost::container::basic_string<CharT, Traits, Alloc> >
        {
            static const bool value = true;
        };

        template<typename Target, typename Source>
        struct is_arithmetic_and_not_xchars
        {
            static const bool value = ( boost::type_traits::ice_and< boost::is_arithmetic<Source>::value, boost::is_arithmetic<Target>::value, boost::type_traits::ice_not< detail::is_char_or_wchar<Target>::value >::value, boost::type_traits::ice_not< detail::is_char_or_wchar<Source>::value >::value >::value )
# 2149 "/usr/include/boost/lexical_cast.hpp" 3 4
             ;
        };






        template<typename Target, typename Source>
        struct is_xchar_to_xchar
        {
            static const bool value = ( boost::type_traits::ice_or< boost::type_traits::ice_and< is_same<Source,Target>::value, is_char_or_wchar<Target>::value >::value, boost::type_traits::ice_and< boost::type_traits::ice_eq< sizeof(char),sizeof(Target)>::value, boost::type_traits::ice_eq< sizeof(char),sizeof(Source)>::value, is_char_or_wchar<Target>::value, is_char_or_wchar<Source>::value >::value >::value )
# 2175 "/usr/include/boost/lexical_cast.hpp" 3 4
             ;
        };

        template<typename Target, typename Source>
        struct is_char_array_to_stdstring
        {
            static const bool value = false;
        };

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
        {
            static const bool value = true;
        };

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
        {
            static const bool value = true;
        };

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
        {
            static const bool value = true;
        };

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_stdstring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
        {
            static const bool value = true;
        };







        template<typename Target, typename Source>
        struct lexical_cast_do_cast
        {
            static inline Target lexical_cast_impl(const Source& arg)
            {
                typedef lexical_cast_stream_traits<Source, Target> stream_trait;

                typedef detail::lexical_stream_limited_src<
                    typename stream_trait::char_type,
                    typename stream_trait::traits,
                    stream_trait::requires_stringbuf
                > interpreter_type;


                Target result;

                typename stream_trait::char_type buf[stream_trait::len_t::value + 1];
                stream_trait::len_t::check_coverage();

                interpreter_type interpreter(buf, buf + stream_trait::len_t::value + 1);


                if(!(interpreter.operator <<(arg) && interpreter.operator >>(result)))
                  throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));

                return result;
            }
        };




        template <typename Source>
        struct lexical_cast_copy
        {
            static inline const Source& lexical_cast_impl(const Source &arg)
            {
                return arg;
            }
        };

        template <class Source, class Target >
        struct detect_precision_loss
        {
         typedef boost::numeric::Trunc<Source> Rounder;
         typedef Source source_type ;

         typedef typename mpl::if_<
            boost::is_arithmetic<Source>, Source, Source const&
          >::type argument_type ;

         static source_type nearbyint ( argument_type s )
         {
            const source_type near_int = Rounder::nearbyint(s);
            if (near_int) {
                const source_type orig_div_round = s / near_int;
                const source_type eps = std::numeric_limits<source_type>::epsilon();

                if ((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps)
                    throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
            }

            return s ;
         }

         typedef typename Rounder::round_style round_style;
        } ;

        template <class Source, class Target >
        struct nothrow_overflow_handler
        {
          void operator() ( boost::numeric::range_check_result r )
          {
            if (r != boost::numeric::cInRange)
                throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
          }
        } ;

        template <typename Target, typename Source>
        struct lexical_cast_dynamic_num_not_ignoring_minus
        {
            static inline Target lexical_cast_impl(const Source &arg)
            {
                return boost::numeric::converter<
                        Target,
                        Source,
                        boost::numeric::conversion_traits<Target,Source>,
                        nothrow_overflow_handler<Source, Target>,
                        detect_precision_loss<Source, Target>
                >::convert(arg);
            }
        };

        template <typename Target, typename Source>
        struct lexical_cast_dynamic_num_ignoring_minus
        {
            static inline Target lexical_cast_impl(const Source &arg)
            {
                typedef typename boost::mpl::eval_if_c<
                        boost::is_float<Source>::value,
                        boost::mpl::identity<Source>,
                        boost::make_unsigned<Source>
                >::type usource_t;

                typedef boost::numeric::converter<
                        Target,
                        usource_t,
                        boost::numeric::conversion_traits<Target,usource_t>,
                        nothrow_overflow_handler<usource_t, Target>,
                        detect_precision_loss<usource_t, Target>
                > converter_t;

                return (
                    arg < 0 ? 0u - converter_t::convert(0u - arg) : converter_t::convert(arg)
                );
            }
        };
# 2350 "/usr/include/boost/lexical_cast.hpp" 3 4
        template <typename Target, typename Source>
        struct lexical_cast_dynamic_num
        {
            static inline Target lexical_cast_impl(const Source &arg)
            {
                typedef typename boost::mpl::if_c<
                    boost::type_traits::ice_and<
                        boost::type_traits::ice_or<
                            boost::is_signed<Source>::value,
                            boost::is_float<Source>::value
                        >::value,
                        boost::type_traits::ice_not<
                            boost::is_same<Source, bool>::value
                        >::value,
                        boost::type_traits::ice_not<
                            boost::is_same<Target, bool>::value
                        >::value,
                        boost::is_unsigned<Target>::value
                    >::value,
                    lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
                    lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
                >::type caster_type;

                return caster_type::lexical_cast_impl(arg);
            }
        };
    }

    template <typename Target, typename Source>
    inline Target lexical_cast(const Source &arg)
    {
        typedef typename boost::detail::array_to_pointer_decay<Source>::type src;

        typedef typename boost::type_traits::ice_or<
                boost::detail::is_xchar_to_xchar<Target, src >::value,
                boost::detail::is_char_array_to_stdstring<Target, src >::value,
                boost::type_traits::ice_and<
                     boost::is_same<Target, src >::value,
                     boost::detail::is_stdstring<Target >::value
                >::value
        > shall_we_copy_t;

        typedef typename
                boost::detail::is_arithmetic_and_not_xchars<Target, src > shall_we_copy_with_dynamic_check_t;

        typedef typename boost::mpl::if_c<
            shall_we_copy_t::value,
            boost::detail::lexical_cast_copy<src >,
            typename boost::mpl::if_c<
                 shall_we_copy_with_dynamic_check_t::value,
                 boost::detail::lexical_cast_dynamic_num<Target, src >,
                 boost::detail::lexical_cast_do_cast<Target, src >
            >::type
        >::type caster_type;

        return caster_type::lexical_cast_impl(arg);
    }

    template <typename Target, typename CharType>
    inline Target lexical_cast(const CharType* chars, std::size_t count)
    {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((boost::detail::is_char_or_wchar<CharType>::value) == 0 ? false : true) >)> boost_static_assert_typedef_2412
                                                                  ;

        return boost::lexical_cast<Target>(
            boost::iterator_range<const CharType*>(chars, chars + count)
        );
    }

}
# 14 "/usr/include/boost/date_time/string_parse_tree.hpp" 2 3 4






namespace boost { namespace date_time {


template<typename charT>
struct parse_match_result
{
  parse_match_result() :
    match_depth(0),
    current_match(-1)
  {}
  typedef std::basic_string<charT> string_type;
  string_type remaining() const
  {
    if (match_depth == cache.size()) {
      return string_type();
    }
    if (current_match == -1) {
      return cache;
    }

    return string_type(cache, match_depth);
  }
  charT last_char() const
  {
    return cache[cache.size()-1];
  }




  bool has_remaining() const
  {
    return (cache.size() > match_depth);
  }


  string_type cache;
  unsigned short match_depth;
  short current_match;
  enum PARSE_STATE { PARSE_ERROR= -1 };
};


template<typename charT>
std::basic_ostream<charT>&
operator<<(std::basic_ostream<charT>& os, parse_match_result<charT>& mr)
{
  os << "cm: " << mr.current_match
     << " C: '" << mr.cache
     << "' md: " << mr.match_depth
     << " R: " << mr.remaining();
  return os;
}
# 82 "/usr/include/boost/date_time/string_parse_tree.hpp" 3 4
template<typename charT>
struct string_parse_tree
{



  typedef std::multimap<charT, string_parse_tree > ptree_coll;

  typedef typename ptree_coll::value_type value_type;
  typedef typename ptree_coll::iterator iterator;
  typedef typename ptree_coll::const_iterator const_iterator;
  typedef std::basic_string<charT> string_type;
  typedef std::vector<std::basic_string<charT> > collection_type;
  typedef parse_match_result<charT> parse_match_result_type;






  string_parse_tree(collection_type names, unsigned int starting_point=0)
  {

    unsigned short index = 0;
    while (index != names.size() ) {
      string_type s = boost::algorithm::to_lower_copy(names[index]);
      insert(s, static_cast<unsigned short>(index + starting_point));
      index++;
    }

    index++;
  }


  string_parse_tree(short value = -1) :
    m_value(value)
  {}
  ptree_coll m_next_chars;
  short m_value;

  void insert(const string_type& s, unsigned short value)
  {
    unsigned int i = 0;
    iterator ti;
    while(i < s.size()) {
      if (i==0) {
        if (i == (s.size()-1)) {
          ti = m_next_chars.insert(value_type(s[i],
                                              string_parse_tree<charT>(value)));
        }
        else {
          ti = m_next_chars.insert(value_type(s[i],
                                              string_parse_tree<charT>()));
        }
      }
      else {
        if (i == (s.size()-1)) {
          ti = ti->second.m_next_chars.insert(value_type(s[i],
                                                         string_parse_tree<charT>(value)));
        }

        else {
          ti = ti->second.m_next_chars.insert(value_type(s[i],
                                                         string_parse_tree<charT>()));
        }

      }
      i++;
    }
  }
# 165 "/usr/include/boost/date_time/string_parse_tree.hpp" 3 4
  short
  match(std::istreambuf_iterator<charT>& sitr,
        std::istreambuf_iterator<charT>& stream_end,
        parse_match_result_type& result,
        unsigned int& level) const
  {

    level++;
    charT c;


    bool adv_itr = true;
    if (level > result.cache.size()) {
      if (sitr == stream_end) return 0;
      c = static_cast<charT>(std::tolower(*sitr));


    }
    else {


      adv_itr = false;
      c = static_cast<charT>(std::tolower(result.cache[level-1]));
    }
    const_iterator litr = m_next_chars.lower_bound(c);
    const_iterator uitr = m_next_chars.upper_bound(c);
    while (litr != uitr) {
      if(adv_itr) {
        sitr++;
        result.cache += c;
      }
      if (litr->second.m_value != -1) {
        if (result.match_depth < level) {
          result.current_match = litr->second.m_value;
          result.match_depth = static_cast<unsigned short>(level);
        }
        litr->second.match(sitr, stream_end,
                           result, level);
        level--;
      }
      else {
        litr->second.match(sitr, stream_end,
                           result, level);
        level--;
      }

      if(level <= result.cache.size()) {
        adv_itr = false;
      }

      litr++;
    }
    return result.current_match;

  }






  parse_match_result_type
  match(std::istreambuf_iterator<charT>& sitr,
        std::istreambuf_iterator<charT>& stream_end) const
  {

    unsigned int level = 0;

    parse_match_result_type result;
    match(sitr, stream_end, result, level);
    return result;
  }

  void printme(std::ostream& os, int& level)
  {
    level++;
    iterator itr = m_next_chars.begin();
    iterator end = m_next_chars.end();

    while (itr != end) {
      os << "level:  " << level
         << " node:  " << itr->first
         << " value: " << itr->second.m_value
         << std::endl;
      itr->second.printme(os, level);
      itr++;
    }
    level--;
  }

  void print(std::ostream& os)
  {
    int level = 0;
    printme(os, level);
  }

  void printmatch(std::ostream& os, charT c)
  {
    iterator litr = m_next_chars.lower_bound(c);
    iterator uitr = m_next_chars.upper_bound(c);
    os << "matches for: " << c << std::endl;
    while (litr != uitr) {
      os << " node:  " << litr->first
         << " value: " << litr->second.m_value
         << std::endl;
      litr++;
    }
  }

};


} }
# 15 "/usr/include/boost/date_time/period_parser.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/string_convert.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/string_convert.hpp" 3 4
namespace boost {
namespace date_time {




  template<class InputT, class OutputT>
  inline
  std::basic_string<OutputT> convert_string_type(const std::basic_string<InputT>& inp_str)
  {
    typedef std::basic_string<InputT> input_type;
    typedef std::basic_string<OutputT> output_type;
    output_type result;
    result.insert(result.begin(), inp_str.begin(), inp_str.end());
    return result;
  }

}}
# 16 "/usr/include/boost/date_time/period_parser.hpp" 2 3 4


namespace boost { namespace date_time {
# 35 "/usr/include/boost/date_time/period_parser.hpp" 3 4
  template<class date_type, typename CharT>
  class period_parser {
  public:
    typedef std::basic_string<CharT> string_type;
    typedef CharT char_type;

    typedef std::istreambuf_iterator<CharT> stream_itr_type;
    typedef string_parse_tree<CharT> parse_tree_type;
    typedef typename parse_tree_type::parse_match_result_type match_results;
    typedef std::vector<std::basic_string<CharT> > collection_type;

    static const char_type default_period_separator[2];
    static const char_type default_period_start_delimeter[2];
    static const char_type default_period_open_range_end_delimeter[2];
    static const char_type default_period_closed_range_end_delimeter[2];

    enum period_range_option { AS_OPEN_RANGE, AS_CLOSED_RANGE };


    period_parser(period_range_option range_opt = AS_CLOSED_RANGE,
                  const char_type* const period_separator = default_period_separator,
                  const char_type* const period_start_delimeter = default_period_start_delimeter,
                  const char_type* const period_open_range_end_delimeter = default_period_open_range_end_delimeter,
                  const char_type* const period_closed_range_end_delimeter = default_period_closed_range_end_delimeter)
      : m_range_option(range_opt)
    {
      delimiters.push_back(string_type(period_separator));
      delimiters.push_back(string_type(period_start_delimeter));
      delimiters.push_back(string_type(period_open_range_end_delimeter));
      delimiters.push_back(string_type(period_closed_range_end_delimeter));
    }

    period_parser(const period_parser<date_type,CharT>& p_parser)
    {
      this->delimiters = p_parser.delimiters;
      this->m_range_option = p_parser.m_range_option;
    }

    period_range_option range_option() const
    {
      return m_range_option;
    }
    void range_option(period_range_option option)
    {
      m_range_option = option;
    }
    collection_type delimiter_strings() const
    {
      return delimiters;
    }
    void delimiter_strings(const string_type& separator,
                           const string_type& start_delim,
                           const string_type& open_end_delim,
                           const string_type& closed_end_delim)
    {
      delimiters.clear();
      delimiters.push_back(separator);
      delimiters.push_back(start_delim);
      delimiters.push_back(open_end_delim);
      delimiters.push_back(closed_end_delim);
    }
# 119 "/usr/include/boost/date_time/period_parser.hpp" 3 4
    template<class period_type, class duration_type, class facet_type>
    period_type get_period(stream_itr_type& sitr,
                           stream_itr_type& stream_end,
                           std::ios_base& a_ios,
                           const period_type& ,
                           const duration_type& dur_unit,
                           const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      typedef typename period_type::point_type point_type;
      point_type p1(not_a_date_time), p2(not_a_date_time);


      consume_delim(sitr, stream_end, delimiters[START]);
      facet.get(sitr, stream_end, a_ios, p1);
      consume_delim(sitr, stream_end, delimiters[SEPARATOR]);
      facet.get(sitr, stream_end, a_ios, p2);


      if (m_range_option == AS_CLOSED_RANGE) {
        consume_delim(sitr, stream_end, delimiters[CLOSED_END]);

        p2 += dur_unit;
      }
      else {
        consume_delim(sitr, stream_end, delimiters[OPEN_END]);
      }

      return period_type(p1, p2);
    }

  private:
    collection_type delimiters;
    period_range_option m_range_option;

    enum delim_ids { SEPARATOR, START, OPEN_END, CLOSED_END };


    void consume_delim(stream_itr_type& sitr,
                       stream_itr_type& stream_end,
                       const string_type& delim) const
    {





      string_type s;
      for(unsigned int i = 0; i < delim.length() && sitr != stream_end; ++i) {
        s += *sitr;
        ++sitr;
      }
      if(s != delim) {
        boost::throw_exception(std::ios_base::failure("Parse failed. Expected '"
          + convert_string_type<char_type,char>(delim) + "' but found '" + convert_string_type<char_type,char>(s) + "'"));
      }
    }
  };

  template <class date_type, class char_type>
  const typename period_parser<date_type, char_type>::char_type
  period_parser<date_type, char_type>::default_period_separator[2] = {'/'};

  template <class date_type, class char_type>
  const typename period_parser<date_type, char_type>::char_type
  period_parser<date_type, char_type>::default_period_start_delimeter[2] = {'['};

  template <class date_type, class char_type>
  const typename period_parser<date_type, char_type>::char_type
  period_parser<date_type, char_type>::default_period_open_range_end_delimeter[2] = {')'};

  template <class date_type, class char_type>
  const typename period_parser<date_type, char_type>::char_type
  period_parser<date_type, char_type>::default_period_closed_range_end_delimeter[2] = {']'};

 } }
# 24 "/usr/include/boost/date_time/date_facet.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_generator_formatter.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/date_generator_formatter.hpp" 3 4
namespace boost {
namespace date_time {
# 37 "/usr/include/boost/date_time/date_generator_formatter.hpp" 3 4
  template <class date_type, class CharT, class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
  class date_generator_formatter {
    public:
      typedef partial_date<date_type> partial_date_type;
      typedef nth_kday_of_month<date_type> nth_kday_type;
      typedef first_kday_of_month<date_type> first_kday_type;
      typedef last_kday_of_month<date_type> last_kday_type;
      typedef first_kday_after<date_type> kday_after_type;
      typedef first_kday_before<date_type> kday_before_type;

      typedef CharT char_type;
      typedef std::basic_string<char_type> string_type;
      typedef std::vector<string_type> collection_type;
      static const char_type first_string[6];
      static const char_type second_string[7];
      static const char_type third_string[6];
      static const char_type fourth_string[7];
      static const char_type fifth_string[6];
      static const char_type last_string[5];
      static const char_type before_string[8];
      static const char_type after_string[6];
      static const char_type of_string[3];

      enum phrase_elements {first=0, second, third, fourth, fifth, last,
                         before, after, of, number_of_phrase_elements};


      date_generator_formatter()
      {
        phrase_strings.reserve(number_of_phrase_elements);
        phrase_strings.push_back(string_type(first_string));
        phrase_strings.push_back(string_type(second_string));
        phrase_strings.push_back(string_type(third_string));
        phrase_strings.push_back(string_type(fourth_string));
        phrase_strings.push_back(string_type(fifth_string));
        phrase_strings.push_back(string_type(last_string));
        phrase_strings.push_back(string_type(before_string));
        phrase_strings.push_back(string_type(after_string));
        phrase_strings.push_back(string_type(of_string));
      }


      date_generator_formatter(const string_type& first_str,
                               const string_type& second_str,
                               const string_type& third_str,
                               const string_type& fourth_str,
                               const string_type& fifth_str,
                               const string_type& last_str,
                               const string_type& before_str,
                               const string_type& after_str,
                               const string_type& of_str)
      {
        phrase_strings.reserve(number_of_phrase_elements);
        phrase_strings.push_back(first_str);
        phrase_strings.push_back(second_str);
        phrase_strings.push_back(third_str);
        phrase_strings.push_back(fourth_str);
        phrase_strings.push_back(fifth_str);
        phrase_strings.push_back(last_str);
        phrase_strings.push_back(before_str);
        phrase_strings.push_back(after_str);
        phrase_strings.push_back(of_str);
      }
# 114 "/usr/include/boost/date_time/date_generator_formatter.hpp" 3 4
      void elements(const collection_type& new_strings,
                    phrase_elements beg_pos=first)
      {
        if(beg_pos < number_of_phrase_elements) {
          typename collection_type::iterator itr = phrase_strings.begin();
          itr += beg_pos;
          std::copy(new_strings.begin(), new_strings.end(),
                    itr);

        }
      }


      template<class facet_type>
      OutItrT put_partial_date(OutItrT next, std::ios_base& a_ios,
                               CharT a_fill, const partial_date_type& pd,
                               const facet_type& facet) const
      {
        facet.put(next, a_ios, a_fill, pd.day());
        next = a_fill;
        facet.put(next, a_ios, a_fill, pd.month());
        return next;
      }


      template<class facet_type>
      OutItrT put_nth_kday(OutItrT next, std::ios_base& a_ios,
                           CharT a_fill, const nth_kday_type& nkd,
                           const facet_type& facet) const
      {
        put_string(next, phrase_strings[nkd.nth_week() -1]);
        next = a_fill;
        facet.put(next, a_ios, a_fill, nkd.day_of_week());
        next = a_fill;
        put_string(next, string_type(of_string));
        next = a_fill;
        facet.put(next, a_ios, a_fill, nkd.month());
        return next;
      }


      template<class facet_type>
      OutItrT put_first_kday(OutItrT next, std::ios_base& a_ios,
                             CharT a_fill, const first_kday_type& fkd,
                             const facet_type& facet) const
      {
        put_string(next, phrase_strings[first]);
        next = a_fill;
        facet.put(next, a_ios, a_fill, fkd.day_of_week());
        next = a_fill;
        put_string(next, string_type(of_string));
        next = a_fill;
        facet.put(next, a_ios, a_fill, fkd.month());
        return next;
      }


      template<class facet_type>
      OutItrT put_last_kday(OutItrT next, std::ios_base& a_ios,
                           CharT a_fill, const last_kday_type& lkd,
                           const facet_type& facet) const
      {
        put_string(next, phrase_strings[last]);
        next = a_fill;
        facet.put(next, a_ios, a_fill, lkd.day_of_week());
        next = a_fill;
        put_string(next, string_type(of_string));
        next = a_fill;
        facet.put(next, a_ios, a_fill, lkd.month());
        return next;
      }


      template<class facet_type>
      OutItrT put_kday_before(OutItrT next, std::ios_base& a_ios,
                              CharT a_fill, const kday_before_type& fkb,
                              const facet_type& facet) const
      {
        facet.put(next, a_ios, a_fill, fkb.day_of_week());
        next = a_fill;
        put_string(next, phrase_strings[before]);
        return next;
      }


      template<class facet_type>
      OutItrT put_kday_after(OutItrT next, std::ios_base& a_ios,
                             CharT a_fill, const kday_after_type& fka,
                             const facet_type& facet) const
      {
        facet.put(next, a_ios, a_fill, fka.day_of_week());
        next = a_fill;
        put_string(next, phrase_strings[after]);
        return next;
      }


    private:
      collection_type phrase_strings;


      OutItrT put_string(OutItrT next, const string_type& str) const
      {
        typename string_type::const_iterator itr = str.begin();
        while(itr != str.end()) {
          *next = *itr;
          ++itr;
          ++next;
        }
        return next;
      }
  };

  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::first_string[6] =
    {'f','i','r','s','t'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::second_string[7] =
    {'s','e','c','o','n','d'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::third_string[6] =
    {'t','h','i','r','d'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::fourth_string[7] =
    {'f','o','u','r','t','h'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::fifth_string[6] =
    {'f','i','f','t','h'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::last_string[5] =
    {'l','a','s','t'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::before_string[8] =
    {'b','e','f','o','r','e'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::after_string[6] =
    {'a','f','t','e','r'};
  template<class date_type, class CharT, class OutItrT>
  const typename date_generator_formatter<date_type, CharT, OutItrT>::char_type
  date_generator_formatter<date_type, CharT, OutItrT>::of_string[3] =
    {'o','f'};
} }
# 25 "/usr/include/boost/date_time/date_facet.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_generator_parser.hpp" 1 3 4
# 20 "/usr/include/boost/date_time/date_generator_parser.hpp" 3 4
# 1 "/usr/include/boost/date_time/format_date_parser.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/format_date_parser.hpp" 3 4
# 1 "/usr/include/boost/date_time/strings_from_facet.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/strings_from_facet.hpp" 3 4
namespace boost { namespace date_time {
# 32 "/usr/include/boost/date_time/strings_from_facet.hpp" 3 4
template<typename charT>
std::vector<std::basic_string<charT> >
gather_month_strings(const std::locale& locale, bool short_strings=true)
{
  typedef std::basic_string<charT> string_type;
  typedef std::vector<string_type> collection_type;
  typedef std::basic_ostringstream<charT> ostream_type;
  typedef std::ostreambuf_iterator<charT> ostream_iter_type;
  typedef std::basic_ostringstream<charT> stringstream_type;
  typedef std::time_put<charT> time_put_facet_type;
  charT short_fmt[3] = { '%', 'b' };
  charT long_fmt[3] = { '%', 'B' };
  collection_type months;
  string_type outfmt(short_fmt);
  if (!short_strings) {
    outfmt = long_fmt;
  }
  {


    const charT* p_outfmt = outfmt.c_str(), *p_outfmt_end = p_outfmt + outfmt.size();
    tm tm_value = {};
    for (int m=0; m < 12; m++) {
      tm_value.tm_mon = m;
      stringstream_type ss;
      ostream_iter_type oitr(ss);
      std::use_facet<time_put_facet_type>(locale).put(oitr, ss, ss.fill(),
                                                      &tm_value,
                                                      p_outfmt,
                                                      p_outfmt_end);
      months.push_back(ss.str());
    }
  }
  return months;
}
# 82 "/usr/include/boost/date_time/strings_from_facet.hpp" 3 4
template<typename charT>
std::vector<std::basic_string<charT> >
gather_weekday_strings(const std::locale& locale, bool short_strings=true)
{
  typedef std::basic_string<charT> string_type;
  typedef std::vector<string_type> collection_type;
  typedef std::basic_ostringstream<charT> ostream_type;
  typedef std::ostreambuf_iterator<charT> ostream_iter_type;
  typedef std::basic_ostringstream<charT> stringstream_type;
  typedef std::time_put<charT> time_put_facet_type;
  charT short_fmt[3] = { '%', 'a' };
  charT long_fmt[3] = { '%', 'A' };

  collection_type weekdays;


  string_type outfmt(short_fmt);
  if (!short_strings) {
    outfmt = long_fmt;
  }
  {


    const charT* p_outfmt = outfmt.c_str(), *p_outfmt_end = p_outfmt + outfmt.size();
    tm tm_value = {};
    for (int i=0; i < 7; i++) {
      tm_value.tm_wday = i;
      stringstream_type ss;
      ostream_iter_type oitr(ss);
      std::use_facet<time_put_facet_type>(locale).put(oitr, ss, ss.fill(),
                                                      &tm_value,
                                                      p_outfmt,
                                                      p_outfmt_end);

      weekdays.push_back(ss.str());
    }
  }
  return weekdays;
}

} }
# 17 "/usr/include/boost/date_time/format_date_parser.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/special_values_parser.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/special_values_parser.hpp" 3 4
namespace boost { namespace date_time {
# 32 "/usr/include/boost/date_time/special_values_parser.hpp" 3 4
  template<class date_type, typename charT>
  class special_values_parser
  {
   public:
    typedef std::basic_string<charT> string_type;

    typedef std::istreambuf_iterator<charT> stream_itr_type;



    typedef typename date_type::duration_type duration_type;


    typedef string_parse_tree<charT> parse_tree_type;
    typedef typename parse_tree_type::parse_match_result_type match_results;
    typedef std::vector<std::basic_string<charT> > collection_type;

    typedef charT char_type;
    static const char_type nadt_string[16];
    static const char_type neg_inf_string[10];
    static const char_type pos_inf_string[10];
    static const char_type min_date_time_string[18];
    static const char_type max_date_time_string[18];


    special_values_parser()
    {
      sv_strings(string_type(nadt_string),
                 string_type(neg_inf_string),
                 string_type(pos_inf_string),
                 string_type(min_date_time_string),
                 string_type(max_date_time_string));
    }


    special_values_parser(const string_type& nadt_str,
                          const string_type& neg_inf_str,
                          const string_type& pos_inf_str,
                          const string_type& min_dt_str,
                          const string_type& max_dt_str)
    {
      sv_strings(nadt_str, neg_inf_str, pos_inf_str, min_dt_str, max_dt_str);
    }

    special_values_parser(typename collection_type::iterator beg, typename collection_type::iterator end)
    {
      collection_type phrases;
      std::copy(beg, end, std::back_inserter(phrases));
      m_sv_strings = parse_tree_type(phrases, static_cast<int>(not_a_date_time));
    }

    special_values_parser(const special_values_parser<date_type,charT>& svp)
    {
      this->m_sv_strings = svp.m_sv_strings;
    }


    void sv_strings(const string_type& nadt_str,
                    const string_type& neg_inf_str,
                    const string_type& pos_inf_str,
                    const string_type& min_dt_str,
                    const string_type& max_dt_str)
    {
      collection_type phrases;
      phrases.push_back(nadt_str);
      phrases.push_back(neg_inf_str);
      phrases.push_back(pos_inf_str);
      phrases.push_back(min_dt_str);
      phrases.push_back(max_dt_str);
      m_sv_strings = parse_tree_type(phrases, static_cast<int>(not_a_date_time));
    }






    bool match(stream_itr_type& sitr,
                        stream_itr_type& str_end,
                        match_results& mr) const
    {
      unsigned int level = 0;
      m_sv_strings.match(sitr, str_end, mr, level);
      return (mr.current_match != match_results::PARSE_ERROR);
    }
# 130 "/usr/include/boost/date_time/special_values_parser.hpp" 3 4
   private:
    parse_tree_type m_sv_strings;

  };

  template<class date_type, class CharT>
  const typename special_values_parser<date_type, CharT>::char_type
  special_values_parser<date_type, CharT>::nadt_string[16] =
  {'n','o','t','-','a','-','d','a','t','e','-','t','i','m','e'};
  template<class date_type, class CharT>
  const typename special_values_parser<date_type, CharT>::char_type
  special_values_parser<date_type, CharT>::neg_inf_string[10] =
  {'-','i','n','f','i','n','i','t','y'};
  template<class date_type, class CharT>
  const typename special_values_parser<date_type, CharT>::char_type
  special_values_parser<date_type, CharT>::pos_inf_string[10] =
  {'+','i','n','f','i','n','i','t','y'};
  template<class date_type, class CharT>
  const typename special_values_parser<date_type, CharT>::char_type
  special_values_parser<date_type, CharT>::min_date_time_string[18] =
  {'m','i','n','i','m','u','m','-','d','a','t','e','-','t','i','m','e'};
  template<class date_type, class CharT>
  const typename special_values_parser<date_type, CharT>::char_type
  special_values_parser<date_type, CharT>::max_date_time_string[18] =
  {'m','a','x','i','m','u','m','-','d','a','t','e','-','t','i','m','e'};

} }
# 18 "/usr/include/boost/date_time/format_date_parser.hpp" 2 3 4





# 1 "/usr/include/c++/4.8/cctype" 1 3 4
# 39 "/usr/include/c++/4.8/cctype" 3 4
       
# 40 "/usr/include/c++/4.8/cctype" 3
# 24 "/usr/include/boost/date_time/format_date_parser.hpp" 2 3 4
# 34 "/usr/include/boost/date_time/format_date_parser.hpp" 3 4
namespace boost { namespace date_time {






template<typename int_type, typename charT>
inline
int_type
fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
                    std::istreambuf_iterator<charT>& stream_end,
                    parse_match_result<charT>& mr,
                    unsigned int length,
                    const charT& fill_char)
{

  unsigned int j = 0;

  while (j < length && itr != stream_end &&
      (std::isdigit(*itr) || *itr == fill_char)) {
    if(*itr == fill_char) {


      mr.cache += ('0');
    }
    else {
      mr.cache += (*itr);
    }
    itr++;
    j++;
  }
  int_type i = -1;

  if(mr.cache.size() < length) {
    return i;
  }
  try {
    i = boost::lexical_cast<int_type>(mr.cache);
  }catch(bad_lexical_cast&){

  }
  return i;
}






template<typename int_type, typename charT>
inline
int_type
fixed_string_to_int(std::istreambuf_iterator<charT>& itr,
                    std::istreambuf_iterator<charT>& stream_end,
                    parse_match_result<charT>& mr,
                    unsigned int length)
{
  return fixed_string_to_int<int_type, charT>(itr, stream_end, mr, length, '0');
}





template<typename int_type, typename charT>
inline
int_type
var_string_to_int(std::istreambuf_iterator<charT>& itr,
                  const std::istreambuf_iterator<charT>& stream_end,
                  unsigned int max_length)
{
  typedef std::basic_string<charT> string_type;
  unsigned int j = 0;
  string_type s;
  while (itr != stream_end && (j < max_length) && std::isdigit(*itr)) {
    s += (*itr);
    ++itr;
    ++j;
  }
  int_type i = -1;
  if(!s.empty()) {
    i = boost::lexical_cast<int_type>(s);
  }
  return i;
}
# 150 "/usr/include/boost/date_time/format_date_parser.hpp" 3 4
template<class date_type, typename charT>
class format_date_parser
{
 public:
  typedef std::basic_string<charT> string_type;
  typedef std::basic_istringstream<charT> stringstream_type;
  typedef std::istreambuf_iterator<charT> stream_itr_type;
  typedef typename string_type::const_iterator const_itr;
  typedef typename date_type::year_type year_type;
  typedef typename date_type::month_type month_type;
  typedef typename date_type::day_type day_type;
  typedef typename date_type::duration_type duration_type;
  typedef typename date_type::day_of_week_type day_of_week_type;
  typedef typename date_type::day_of_year_type day_of_year_type;
  typedef string_parse_tree<charT> parse_tree_type;
  typedef typename parse_tree_type::parse_match_result_type match_results;
  typedef std::vector<std::basic_string<charT> > input_collection_type;



  format_date_parser(const string_type& format_str,
                     const input_collection_type& month_short_names,
                     const input_collection_type& month_long_names,
                     const input_collection_type& weekday_short_names,
                     const input_collection_type& weekday_long_names) :
    m_format(format_str),
    m_month_short_names(month_short_names, 1),
    m_month_long_names(month_long_names, 1),
    m_weekday_short_names(weekday_short_names),
    m_weekday_long_names(weekday_long_names)
  {}

  format_date_parser(const string_type& format_str,
                     const std::locale& locale) :
    m_format(format_str),
    m_month_short_names(gather_month_strings<charT>(locale), 1),
    m_month_long_names(gather_month_strings<charT>(locale, false), 1),
    m_weekday_short_names(gather_weekday_strings<charT>(locale)),
    m_weekday_long_names(gather_weekday_strings<charT>(locale, false))
  {}

  format_date_parser(const format_date_parser<date_type,charT>& fdp)
  {
    this->m_format = fdp.m_format;
    this->m_month_short_names = fdp.m_month_short_names;
    this->m_month_long_names = fdp.m_month_long_names;
    this->m_weekday_short_names = fdp.m_weekday_short_names;
    this->m_weekday_long_names = fdp.m_weekday_long_names;
  }

  string_type format() const
  {
    return m_format;
  }

  void format(string_type format_str)
  {
    m_format = format_str;
  }

  void short_month_names(const input_collection_type& month_names)
  {
    m_month_short_names = parse_tree_type(month_names, 1);
  }
  void long_month_names(const input_collection_type& month_names)
  {
    m_month_long_names = parse_tree_type(month_names, 1);
  }
  void short_weekday_names(const input_collection_type& weekday_names)
  {
    m_weekday_short_names = parse_tree_type(weekday_names);
  }
  void long_weekday_names(const input_collection_type& weekday_names)
  {
    m_weekday_long_names = parse_tree_type(weekday_names);
  }

  date_type
  parse_date(const string_type& value,
             const string_type& format_str,
             const special_values_parser<date_type,charT>& sv_parser) const
  {
    stringstream_type ss(value);
    stream_itr_type sitr(ss);
    stream_itr_type stream_end;
    return parse_date(sitr, stream_end, format_str, sv_parser);
  }

  date_type
  parse_date(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             const special_values_parser<date_type,charT>& sv_parser) const
  {
    return parse_date(sitr, stream_end, m_format, sv_parser);
  }




  date_type
  parse_date(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str,
             const special_values_parser<date_type,charT>& sv_parser) const
  {
    bool use_current_char = false;


    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

    short year(0), month(0), day(0), day_of_year(0);




    year_type t_year(1400);
    month_type t_month(1);
    day_type t_day(1);
    day_of_week_type wkday(0);


    const_itr itr(format_str.begin());
    while (itr != format_str.end() && (sitr != stream_end)) {
      if (*itr == '%') {
        itr++;
        if (*itr != '%') {
          switch(*itr) {
          case 'a':
            {




              match_results mr = m_weekday_short_names.match(sitr, stream_end);
              if(mr.current_match == match_results::PARSE_ERROR) {

                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              wkday = mr.current_match;
              if (mr.has_remaining()) {
                use_current_char = true;
              }
              break;
            }
          case 'A':
            {




              match_results mr = m_weekday_long_names.match(sitr, stream_end);
              if(mr.current_match == match_results::PARSE_ERROR) {

                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              wkday = mr.current_match;
              if (mr.has_remaining()) {
                use_current_char = true;
              }
              break;
            }
          case 'b':
            {
              match_results mr = m_month_short_names.match(sitr, stream_end);
              if(mr.current_match == match_results::PARSE_ERROR) {

                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              t_month = month_type(mr.current_match);
              if (mr.has_remaining()) {
                use_current_char = true;
              }
              break;
            }
          case 'B':
            {
              match_results mr = m_month_long_names.match(sitr, stream_end);
              if(mr.current_match == match_results::PARSE_ERROR) {

                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              t_month = month_type(mr.current_match);
              if (mr.has_remaining()) {
                use_current_char = true;
              }
              break;
            }
          case 'd':
            {
              match_results mr;
              day = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
              if(day == -1) {
                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              t_day = day_type(day);
              break;
            }
          case 'e':
            {
              match_results mr;
              day = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2, ' ');
              if(day == -1) {
                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              t_day = day_type(day);
              break;
            }
          case 'j':
            {
              match_results mr;
              day_of_year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 3);
              if(day_of_year == -1) {
                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }

              day_of_year_type t_day_of_year(1);
              t_day_of_year = day_of_year_type(day_of_year);
              break;
            }
          case 'm':
            {
              match_results mr;
              month = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
              if(month == -1) {
                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              t_month = month_type(month);
              break;
            }
          case 'Y':
            {
              match_results mr;
              year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 4);
              if(year == -1) {
                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              t_year = year_type(year);
              break;
            }
          case 'y':
            {
              match_results mr;
              year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
              if(year == -1) {
                if(sv_parser.match(sitr, stream_end, mr)) {
                  return date_type(static_cast<special_values>(mr.current_match));
                }
              }
              year += 2000;
              t_year = year_type(year);
              break;
            }
          default:
            {}

          }

        }
        else {
          sitr++;
        }

        itr++;
      }
      else {
        itr++;
        if (use_current_char) {
          use_current_char = false;
        }
        else {
          sitr++;
        }
      }
    }

    if (day_of_year > 0) {
      date_type d(static_cast<unsigned short>(year-1),12,31);
      return d + duration_type(day_of_year);
    }

    return date_type(t_year, t_month, t_day);

  }


  month_type
  parse_month(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str) const
  {
    match_results mr;
    return parse_month(sitr, stream_end, format_str, mr);
  }


  month_type
  parse_month(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str,
             match_results& mr) const
  {
    bool use_current_char = false;


    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
    charT current_char = *sitr;

    short month(0);

    const_itr itr(format_str.begin());
    while (itr != format_str.end() && (sitr != stream_end)) {
      if (*itr == '%') {
        itr++;
        if (*itr != '%') {
          switch(*itr) {
          case 'b':
            {
              mr = m_month_short_names.match(sitr, stream_end);
              month = mr.current_match;
              if (mr.has_remaining()) {
                current_char = mr.last_char();
                use_current_char = true;
              }
              break;
            }
          case 'B':
            {
              mr = m_month_long_names.match(sitr, stream_end);
              month = mr.current_match;
              if (mr.has_remaining()) {
                current_char = mr.last_char();
                use_current_char = true;
              }
              break;
            }
          case 'm':
            {
              month = var_string_to_int<short, charT>(sitr, stream_end, 2);


              break;
            }
          default:
            {}

          }

        }
        else {
          sitr++;
        }

        itr++;
      }
      else {
        itr++;
        if (use_current_char) {
          use_current_char = false;
          current_char = *sitr;
        }
        else {
          sitr++;
        }
      }
    }

    return month_type(month);
  }


  day_type
  parse_var_day_of_month(std::istreambuf_iterator<charT>& sitr,
                         std::istreambuf_iterator<charT>& stream_end) const
  {

    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

    return day_type(var_string_to_int<short, charT>(sitr, stream_end, 2));
  }

  day_type
  parse_day_of_month(std::istreambuf_iterator<charT>& sitr,
                     std::istreambuf_iterator<charT>& stream_end) const
  {

    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }


    match_results mr;
    return day_type(fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2));
  }

  day_of_week_type
  parse_weekday(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str) const
  {
    match_results mr;
    return parse_weekday(sitr, stream_end, format_str, mr);
  }
  day_of_week_type
  parse_weekday(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str,
             match_results& mr) const
  {
    bool use_current_char = false;


    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
    charT current_char = *sitr;

    short wkday(0);

    const_itr itr(format_str.begin());
    while (itr != format_str.end() && (sitr != stream_end)) {
      if (*itr == '%') {
        itr++;
        if (*itr != '%') {
          switch(*itr) {
          case 'a':
            {




              mr = m_weekday_short_names.match(sitr, stream_end);
              wkday = mr.current_match;
              if (mr.has_remaining()) {
                current_char = mr.last_char();
                use_current_char = true;
              }
              break;
            }
          case 'A':
            {




              mr = m_weekday_long_names.match(sitr, stream_end);
              wkday = mr.current_match;
              if (mr.has_remaining()) {
                current_char = mr.last_char();
                use_current_char = true;
              }
              break;
            }
          case 'w':
            {

              wkday = var_string_to_int<short, charT>(sitr, stream_end, 2);
              break;
            }
          default:
            {}

          }

        }
        else {
          sitr++;
        }

        itr++;
      }
      else {
        itr++;
        if (use_current_char) {
          use_current_char = false;
          current_char = *sitr;
        }
        else {
          sitr++;
        }
      }
    }

    return day_of_week_type(wkday);

  }


  year_type
  parse_year(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str) const
  {
    match_results mr;
    return parse_year(sitr, stream_end, format_str, mr);
  }


  year_type
  parse_year(std::istreambuf_iterator<charT>& sitr,
             std::istreambuf_iterator<charT>& stream_end,
             string_type format_str,
             match_results& mr) const
  {
    bool use_current_char = false;


    while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
    charT current_char = *sitr;

    unsigned short year(0);

    const_itr itr(format_str.begin());
    while (itr != format_str.end() && (sitr != stream_end)) {
      if (*itr == '%') {
        itr++;
        if (*itr != '%') {

          switch(*itr) {
          case 'Y':
            {

              year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 4);
              break;
            }
          case 'y':
            {

              year = fixed_string_to_int<short, charT>(sitr, stream_end, mr, 2);
              year += 2000;
              break;
            }
          default:
            {}

          }

        }
        else {
          sitr++;
        }

        itr++;
      }
      else {
        itr++;
        if (use_current_char) {
          use_current_char = false;
          current_char = *sitr;
        }
        else {
          sitr++;
        }
      }
    }

    return year_type(year);
  }


 private:
  string_type m_format;
  parse_tree_type m_month_short_names;
  parse_tree_type m_month_long_names;
  parse_tree_type m_weekday_short_names;
  parse_tree_type m_weekday_long_names;

};

} }
# 21 "/usr/include/boost/date_time/date_generator_parser.hpp" 2 3 4

namespace boost { namespace date_time {
# 40 "/usr/include/boost/date_time/date_generator_parser.hpp" 3 4
  template<class date_type, typename charT>
  class date_generator_parser
  {
   public:
    typedef std::basic_string<charT> string_type;
    typedef std::istreambuf_iterator<charT> stream_itr_type;

    typedef typename date_type::month_type month_type;
    typedef typename date_type::day_of_week_type day_of_week_type;
    typedef typename date_type::day_type day_type;

    typedef string_parse_tree<charT> parse_tree_type;
    typedef typename parse_tree_type::parse_match_result_type match_results;
    typedef std::vector<std::basic_string<charT> > collection_type;

    typedef partial_date<date_type> partial_date_type;
    typedef nth_kday_of_month<date_type> nth_kday_type;
    typedef first_kday_of_month<date_type> first_kday_type;
    typedef last_kday_of_month<date_type> last_kday_type;
    typedef first_kday_after<date_type> kday_after_type;
    typedef first_kday_before<date_type> kday_before_type;

    typedef charT char_type;
    static const char_type first_string[6];
    static const char_type second_string[7];
    static const char_type third_string[6];
    static const char_type fourth_string[7];
    static const char_type fifth_string[6];
    static const char_type last_string[5];
    static const char_type before_string[8];
    static const char_type after_string[6];
    static const char_type of_string[3];

    enum phrase_elements {first=0, second, third, fourth, fifth, last,
                          before, after, of, number_of_phrase_elements};


    date_generator_parser()
    {
      element_strings(string_type(first_string),
                      string_type(second_string),
                      string_type(third_string),
                      string_type(fourth_string),
                      string_type(fifth_string),
                      string_type(last_string),
                      string_type(before_string),
                      string_type(after_string),
                      string_type(of_string));
    }


    date_generator_parser(const string_type& first_str,
                          const string_type& second_str,
                          const string_type& third_str,
                          const string_type& fourth_str,
                          const string_type& fifth_str,
                          const string_type& last_str,
                          const string_type& before_str,
                          const string_type& after_str,
                          const string_type& of_str)
    {
      element_strings(first_str, second_str, third_str, fourth_str, fifth_str,
                      last_str, before_str, after_str, of_str);
    }


    void element_strings(const string_type& first_str,
                         const string_type& second_str,
                         const string_type& third_str,
                         const string_type& fourth_str,
                         const string_type& fifth_str,
                         const string_type& last_str,
                         const string_type& before_str,
                         const string_type& after_str,
                         const string_type& of_str)
    {
      collection_type phrases;
      phrases.push_back(first_str);
      phrases.push_back(second_str);
      phrases.push_back(third_str);
      phrases.push_back(fourth_str);
      phrases.push_back(fifth_str);
      phrases.push_back(last_str);
      phrases.push_back(before_str);
      phrases.push_back(after_str);
      phrases.push_back(of_str);
      m_element_strings = parse_tree_type(phrases, this->first);
    }

    void element_strings(const collection_type& col)
    {
      m_element_strings = parse_tree_type(col, this->first);
    }


    template<class facet_type>
    partial_date_type
    get_partial_date_type(stream_itr_type& sitr,
                          stream_itr_type& stream_end,
                          std::ios_base& a_ios,
                          const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      day_type d(1);
      month_type m(1);
      facet.get(sitr, stream_end, a_ios, d);
      facet.get(sitr, stream_end, a_ios, m);

      return partial_date_type(d,m);
    }


    template<class facet_type>
    nth_kday_type
    get_nth_kday_type(stream_itr_type& sitr,
                      stream_itr_type& stream_end,
                      std::ios_base& a_ios,
                      const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      typename nth_kday_type::week_num wn;
      day_of_week_type wd(0);
      month_type m(1);

      match_results mr = m_element_strings.match(sitr, stream_end);
      switch(mr.current_match) {
        case first : { wn = nth_kday_type::first; break; }
        case second : { wn = nth_kday_type::second; break; }
        case third : { wn = nth_kday_type::third; break; }
        case fourth : { wn = nth_kday_type::fourth; break; }
        case fifth : { wn = nth_kday_type::fifth; break; }
        default:
        {
          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
          std::abort();
        }
      }
      facet.get(sitr, stream_end, a_ios, wd);
      extract_element(sitr, stream_end, of);
      facet.get(sitr, stream_end, a_ios, m);

      return nth_kday_type(wn, wd, m);
    }


    template<class facet_type>
    first_kday_type
    get_first_kday_type(stream_itr_type& sitr,
                        stream_itr_type& stream_end,
                        std::ios_base& a_ios,
                        const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      day_of_week_type wd(0);
      month_type m(1);

      extract_element(sitr, stream_end, first);
      facet.get(sitr, stream_end, a_ios, wd);
      extract_element(sitr, stream_end, of);
      facet.get(sitr, stream_end, a_ios, m);


      return first_kday_type(wd, m);
    }


    template<class facet_type>
    last_kday_type
    get_last_kday_type(stream_itr_type& sitr,
                       stream_itr_type& stream_end,
                       std::ios_base& a_ios,
                       const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      day_of_week_type wd(0);
      month_type m(1);

      extract_element(sitr, stream_end, last);
      facet.get(sitr, stream_end, a_ios, wd);
      extract_element(sitr, stream_end, of);
      facet.get(sitr, stream_end, a_ios, m);


      return last_kday_type(wd, m);
    }


    template<class facet_type>
    kday_before_type
    get_kday_before_type(stream_itr_type& sitr,
                         stream_itr_type& stream_end,
                         std::ios_base& a_ios,
                         const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      day_of_week_type wd(0);

      facet.get(sitr, stream_end, a_ios, wd);
      extract_element(sitr, stream_end, before);

      return kday_before_type(wd);
    }


    template<class facet_type>
    kday_after_type
    get_kday_after_type(stream_itr_type& sitr,
                        stream_itr_type& stream_end,
                        std::ios_base& a_ios,
                        const facet_type& facet) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }

      day_of_week_type wd(0);

      facet.get(sitr, stream_end, a_ios, wd);
      extract_element(sitr, stream_end, after);

      return kday_after_type(wd);
    }

   private:
    parse_tree_type m_element_strings;


    void extract_element(stream_itr_type& sitr,
                         stream_itr_type& stream_end,
                         typename date_generator_parser::phrase_elements ele) const
    {

      while(std::isspace(*sitr) && sitr != stream_end) { ++sitr; }
      match_results mr = m_element_strings.match(sitr, stream_end);
      if(mr.current_match != ele) {
        boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
      }
    }

  };

  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::first_string[6] =
    {'f','i','r','s','t'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::second_string[7] =
    {'s','e','c','o','n','d'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::third_string[6] =
    {'t','h','i','r','d'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::fourth_string[7] =
    {'f','o','u','r','t','h'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::fifth_string[6] =
    {'f','i','f','t','h'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::last_string[5] =
    {'l','a','s','t'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::before_string[8] =
    {'b','e','f','o','r','e'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::after_string[6] =
    {'a','f','t','e','r'};
  template<class date_type, class CharT>
  const typename date_generator_parser<date_type, CharT>::char_type
  date_generator_parser<date_type, CharT>::of_string[3] =
    {'o','f'};

} }
# 26 "/usr/include/boost/date_time/date_facet.hpp" 2 3 4


namespace boost { namespace date_time {
# 46 "/usr/include/boost/date_time/date_facet.hpp" 3 4
  template <class date_type,
            class CharT,
            class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
  class date_facet : public std::locale::facet {
  public:
    typedef typename date_type::duration_type duration_type;

    typedef typename date_type::day_of_week_type day_of_week_type;
    typedef typename date_type::day_type day_type;
    typedef typename date_type::month_type month_type;
    typedef boost::date_time::period<date_type,duration_type> period_type;
    typedef std::basic_string<CharT> string_type;
    typedef CharT char_type;
    typedef boost::date_time::period_formatter<CharT> period_formatter_type;
    typedef boost::date_time::special_values_formatter<CharT> special_values_formatter_type;
    typedef std::vector<std::basic_string<CharT> > input_collection_type;

    typedef date_generator_formatter<date_type, CharT> date_gen_formatter_type;
    typedef partial_date<date_type> partial_date_type;
    typedef nth_kday_of_month<date_type> nth_kday_type;
    typedef first_kday_of_month<date_type> first_kday_type;
    typedef last_kday_of_month<date_type> last_kday_type;
    typedef first_kday_after<date_type> kday_after_type;
    typedef first_kday_before<date_type> kday_before_type;
    static const char_type long_weekday_format[3];
    static const char_type short_weekday_format[3];
    static const char_type long_month_format[3];
    static const char_type short_month_format[3];
    static const char_type default_period_separator[4];
    static const char_type standard_format_specifier[3];
    static const char_type iso_format_specifier[7];
    static const char_type iso_format_extended_specifier[9];
    static const char_type default_date_format[9];
    static std::locale::id id;





    explicit date_facet(::size_t a_ref = 0)
      : std::locale::facet(a_ref),

        m_format(default_date_format),
        m_month_format(short_month_format),
        m_weekday_format(short_weekday_format)
    {}

    explicit date_facet(const char_type* format_str,
                        const input_collection_type& short_names,
                        ::size_t ref_count = 0)
      : std::locale::facet(ref_count),
        m_format(format_str),
        m_month_format(short_month_format),
        m_weekday_format(short_weekday_format),
        m_month_short_names(short_names)
    {}


    explicit date_facet(const char_type* format_str,
                        period_formatter_type per_formatter = period_formatter_type(),
                        special_values_formatter_type sv_formatter = special_values_formatter_type(),
                        date_gen_formatter_type dg_formatter = date_gen_formatter_type(),
                        ::size_t ref_count = 0)
      : std::locale::facet(ref_count),
        m_format(format_str),
        m_month_format(short_month_format),
        m_weekday_format(short_weekday_format),
        m_period_formatter(per_formatter),
        m_date_gen_formatter(dg_formatter),
        m_special_values_formatter(sv_formatter)
     {}
    void format(const char_type* const format_str) {
      m_format = format_str;
    }
    virtual void set_iso_format()
    {
      m_format = iso_format_specifier;
    }
    virtual void set_iso_extended_format()
    {
      m_format = iso_format_extended_specifier;
    }
    void month_format(const char_type* const format_str) {
      m_month_format = format_str;
    }
    void weekday_format(const char_type* const format_str) {
      m_weekday_format = format_str;
    }

    void period_formatter(period_formatter_type per_formatter) {
      m_period_formatter= per_formatter;
    }
    void special_values_formatter(const special_values_formatter_type& svf)
    {
      m_special_values_formatter = svf;
    }
    void short_weekday_names(const input_collection_type& short_names)
    {
      m_weekday_short_names = short_names;
    }
    void long_weekday_names(const input_collection_type& long_names)
    {
      m_weekday_long_names = long_names;
    }

    void short_month_names(const input_collection_type& short_names)
    {
      m_month_short_names = short_names;
    }

    void long_month_names(const input_collection_type& long_names)
    {
      m_month_long_names = long_names;
    }

    void date_gen_phrase_strings(const input_collection_type& new_strings,
                           typename date_gen_formatter_type::phrase_elements beg_pos=date_gen_formatter_type::first)
    {
      m_date_gen_formatter.elements(new_strings, beg_pos);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const date_type& d) const
    {
      if (d.is_special()) {
        return do_put_special(next, a_ios, fill_char, d.as_special());
      }

      return do_put_tm(next, a_ios, fill_char, to_tm(d), m_format);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const duration_type& dd) const
    {
      if (dd.is_special()) {
        return do_put_special(next, a_ios, fill_char, dd.get_rep().as_special());
      }

      typedef std::num_put<CharT, OutItrT> num_put;
      if (std::has_facet<num_put>(a_ios.getloc())) {
        return std::use_facet<num_put>(a_ios.getloc()).put(next, a_ios, fill_char, dd.get_rep().as_number());
      }
      else {
        num_put* f = new num_put();
        std::locale l = std::locale(a_ios.getloc(), f);
        a_ios.imbue(l);
        return f->put(next, a_ios, fill_char, dd.get_rep().as_number());
      }

    }


    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const month_type& m) const
    {




      std::tm dtm;
      std::memset(&dtm, 0, sizeof(dtm));
      dtm.tm_mon = m - 1;
      return do_put_tm(next, a_ios, fill_char, dtm, m_month_format);
    }


    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const day_type& day) const
    {
      std::tm dtm;
      std::memset(&dtm, 0, sizeof(dtm));
      dtm.tm_mday = day.as_number();
      char_type tmp[3] = {'%','d'};
      string_type temp_format(tmp);
      return do_put_tm(next, a_ios, fill_char, dtm, temp_format);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const day_of_week_type& dow) const
    {




      std::tm dtm;
      std::memset(&dtm, 0, sizeof(dtm));
      dtm.tm_wday = dow;
      return do_put_tm(next, a_ios, fill_char, dtm, m_weekday_format);
    }


    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const period_type& p) const
    {
      return m_period_formatter.put_period(next, a_ios, fill_char, p, *this);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const partial_date_type& pd) const
    {
      return m_date_gen_formatter.put_partial_date(next, a_ios, fill_char, pd, *this);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const nth_kday_type& nkd) const
    {
      return m_date_gen_formatter.put_nth_kday(next, a_ios, fill_char, nkd, *this);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const first_kday_type& fkd) const
    {
      return m_date_gen_formatter.put_first_kday(next, a_ios, fill_char, fkd, *this);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const last_kday_type& lkd) const
    {
      return m_date_gen_formatter.put_last_kday(next, a_ios, fill_char, lkd, *this);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const kday_before_type& fkb) const
    {
      return m_date_gen_formatter.put_kday_before(next, a_ios, fill_char, fkb, *this);
    }

    OutItrT put(OutItrT next,
                std::ios_base& a_ios,
                char_type fill_char,
                const kday_after_type& fka) const
    {
      return m_date_gen_formatter.put_kday_after(next, a_ios, fill_char, fka, *this);
    }

  protected:
    virtual OutItrT do_put_special(OutItrT next,
                                   std::ios_base& ,
                                   char_type ,
                                   const boost::date_time::special_values sv) const
    {
      m_special_values_formatter.put_special(next, sv);
      return next;
    }
    virtual OutItrT do_put_tm(OutItrT next,
                              std::ios_base& a_ios,
                              char_type fill_char,
                              const tm& tm_value,
                              string_type a_format) const
    {

      if (m_weekday_long_names.size()) {
        boost::algorithm::replace_all(a_format,
                                      long_weekday_format,
                                      m_weekday_long_names[tm_value.tm_wday]);
      }
      if (m_weekday_short_names.size()) {
        boost::algorithm::replace_all(a_format,
                                      short_weekday_format,
                                      m_weekday_short_names[tm_value.tm_wday]);

      }
      if (m_month_long_names.size()) {
        boost::algorithm::replace_all(a_format,
                                      long_month_format,
                                      m_month_long_names[tm_value.tm_mon]);
      }
      if (m_month_short_names.size()) {
        boost::algorithm::replace_all(a_format,
                                      short_month_format,
                                      m_month_short_names[tm_value.tm_mon]);
      }

      const char_type* p_format = a_format.c_str();
      return std::use_facet<std::time_put<CharT> >(a_ios.getloc()).put(next, a_ios,
                                                                       fill_char,
                                                                       &tm_value,
                                                                       p_format,
                                                                       p_format + a_format.size());
    }
  protected:
    string_type m_format;
    string_type m_month_format;
    string_type m_weekday_format;
    period_formatter_type m_period_formatter;
    date_gen_formatter_type m_date_gen_formatter;
    special_values_formatter_type m_special_values_formatter;
    input_collection_type m_month_short_names;
    input_collection_type m_month_long_names;
    input_collection_type m_weekday_short_names;
    input_collection_type m_weekday_long_names;
  private:
  };

  template <class date_type, class CharT, class OutItrT>
  std::locale::id date_facet<date_type, CharT, OutItrT>::id;

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::long_weekday_format[3] = {'%','A'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::short_weekday_format[3] = {'%','a'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::long_month_format[3] = {'%','B'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::short_month_format[3] = {'%','b'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::default_period_separator[4] = { ' ', '/', ' '};

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::standard_format_specifier[3] =
    {'%', 'x' };

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::iso_format_specifier[7] =
    {'%', 'Y', '%', 'm', '%', 'd' };

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::iso_format_extended_specifier[9] =
    {'%', 'Y', '-', '%', 'm', '-', '%', 'd' };

  template <class date_type, class CharT, class OutItrT>
  const typename date_facet<date_type, CharT, OutItrT>::char_type
  date_facet<date_type, CharT, OutItrT>::default_date_format[9] =
    {'%','Y','-','%','b','-','%','d'};




  template <class date_type,
            class CharT,
            class InItrT = std::istreambuf_iterator<CharT, std::char_traits<CharT> > >
  class date_input_facet : public std::locale::facet {
  public:
    typedef typename date_type::duration_type duration_type;

    typedef typename date_type::day_of_week_type day_of_week_type;
    typedef typename date_type::day_type day_type;
    typedef typename date_type::month_type month_type;
    typedef typename date_type::year_type year_type;
    typedef boost::date_time::period<date_type,duration_type> period_type;
    typedef std::basic_string<CharT> string_type;
    typedef CharT char_type;
    typedef boost::date_time::period_parser<date_type, CharT> period_parser_type;
    typedef boost::date_time::special_values_parser<date_type,CharT> special_values_parser_type;
    typedef std::vector<std::basic_string<CharT> > input_collection_type;
    typedef format_date_parser<date_type, CharT> format_date_parser_type;

    typedef date_generator_parser<date_type, CharT> date_gen_parser_type;
    typedef partial_date<date_type> partial_date_type;
    typedef nth_kday_of_month<date_type> nth_kday_type;
    typedef first_kday_of_month<date_type> first_kday_type;
    typedef last_kday_of_month<date_type> last_kday_type;
    typedef first_kday_after<date_type> kday_after_type;
    typedef first_kday_before<date_type> kday_before_type;

    static const char_type long_weekday_format[3];
    static const char_type short_weekday_format[3];
    static const char_type long_month_format[3];
    static const char_type short_month_format[3];
    static const char_type four_digit_year_format[3];
    static const char_type two_digit_year_format[3];
    static const char_type default_period_separator[4];
    static const char_type standard_format_specifier[3];
    static const char_type iso_format_specifier[7];
    static const char_type iso_format_extended_specifier[9];
    static const char_type default_date_format[9];
    static std::locale::id id;

    explicit date_input_facet(::size_t a_ref = 0)
      : std::locale::facet(a_ref),
        m_format(default_date_format),
        m_month_format(short_month_format),
        m_weekday_format(short_weekday_format),
        m_year_format(four_digit_year_format),
        m_parser(m_format, std::locale::classic())

    {}

    explicit date_input_facet(const string_type& format_str,
                              ::size_t a_ref = 0)
      : std::locale::facet(a_ref),
        m_format(format_str),
        m_month_format(short_month_format),
        m_weekday_format(short_weekday_format),
        m_year_format(four_digit_year_format),
        m_parser(m_format, std::locale::classic())

    {}

    explicit date_input_facet(const string_type& format_str,
                              const format_date_parser_type& date_parser,
                              const special_values_parser_type& sv_parser,
                              const period_parser_type& per_parser,
                              const date_gen_parser_type& date_gen_parser,
                              ::size_t ref_count = 0)
      : std::locale::facet(ref_count),
        m_format(format_str),
        m_month_format(short_month_format),
        m_weekday_format(short_weekday_format),
        m_year_format(four_digit_year_format),
        m_parser(date_parser),
        m_date_gen_parser(date_gen_parser),
        m_period_parser(per_parser),
        m_sv_parser(sv_parser)
    {}


    void format(const char_type* const format_str) {
      m_format = format_str;
    }
    virtual void set_iso_format()
    {
      m_format = iso_format_specifier;
    }
    virtual void set_iso_extended_format()
    {
      m_format = iso_format_extended_specifier;
    }
    void month_format(const char_type* const format_str) {
      m_month_format = format_str;
    }
    void weekday_format(const char_type* const format_str) {
      m_weekday_format = format_str;
    }
    void year_format(const char_type* const format_str) {
      m_year_format = format_str;
    }

    void period_parser(period_parser_type per_parser) {
      m_period_parser = per_parser;
    }
    void short_weekday_names(const input_collection_type& weekday_names)
    {
      m_parser.short_weekday_names(weekday_names);
    }
    void long_weekday_names(const input_collection_type& weekday_names)
    {
      m_parser.long_weekday_names(weekday_names);
    }

    void short_month_names(const input_collection_type& month_names)
    {
      m_parser.short_month_names(month_names);
    }

    void long_month_names(const input_collection_type& month_names)
    {
      m_parser.long_month_names(month_names);
    }

    void date_gen_element_strings(const input_collection_type& col)
    {
      m_date_gen_parser.element_strings(col);
    }
    void date_gen_element_strings(const string_type& first,
                                  const string_type& second,
                                  const string_type& third,
                                  const string_type& fourth,
                                  const string_type& fifth,
                                  const string_type& last,
                                  const string_type& before,
                                  const string_type& after,
                                  const string_type& of)

    {
      m_date_gen_parser.element_strings(first,second,third,fourth,fifth,last,before,after,of);
    }

    void special_values_parser(special_values_parser_type sv_parser)
    {
      m_sv_parser = sv_parser;
    }

    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& ,
               date_type& d) const
    {
      d = m_parser.parse_date(from, to, m_format, m_sv_parser);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& ,
               month_type& m) const
    {
      m = m_parser.parse_month(from, to, m_month_format);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& ,
               day_of_week_type& wd) const
    {
      wd = m_parser.parse_weekday(from, to, m_weekday_format);
      return from;
    }

    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& ,
               day_type& d) const
    {
      d = m_parser.parse_var_day_of_month(from, to);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& ,
               year_type& y) const
    {
      y = m_parser.parse_year(from, to, m_year_format);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               duration_type& dd) const
    {

      while(std::isspace(*from) && from != to) { ++from; }





      char_type c = '\0';

      if(*from == '-' || *from == '+') {
        c = *from;
      }
      typedef std::num_get<CharT, InItrT> num_get;
      typename duration_type::duration_rep_type val = 0;
      std::ios_base::iostate err = std::ios_base::goodbit;

      if (std::has_facet<num_get>(a_ios.getloc())) {
        from = std::use_facet<num_get>(a_ios.getloc()).get(from, to, a_ios, err, val);
      }
      else {
        num_get* ng = new num_get();
        std::locale l = std::locale(a_ios.getloc(), ng);
        a_ios.imbue(l);
        from = ng->get(from, to, a_ios, err, val);
      }
      if(err & std::ios_base::failbit){
        typedef typename special_values_parser_type::match_results match_results;
        match_results mr;
        if(c == '-' || c == '+') {
          mr.cache += c;
        }
        m_sv_parser.match(from, to, mr);
        if(mr.current_match == match_results::PARSE_ERROR) {
          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + mr.cache + "'"));
          std::abort();
        }
        dd = duration_type(static_cast<special_values>(mr.current_match));
      }
      else {
        dd = duration_type(val);
      }
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               period_type& p) const
    {
      p = m_period_parser.get_period(from, to, a_ios, p, duration_type::unit(), *this);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               nth_kday_type& nkd) const
    {
      nkd = m_date_gen_parser.get_nth_kday_type(from, to, a_ios, *this);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               partial_date_type& pd) const
    {

      pd = m_date_gen_parser.get_partial_date_type(from, to, a_ios, *this);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               first_kday_type& fkd) const
    {
      fkd = m_date_gen_parser.get_first_kday_type(from, to, a_ios, *this);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               last_kday_type& lkd) const
    {
      lkd = m_date_gen_parser.get_last_kday_type(from, to, a_ios, *this);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               kday_before_type& fkb) const
    {
      fkb = m_date_gen_parser.get_kday_before_type(from, to, a_ios, *this);
      return from;
    }
    InItrT get(InItrT& from,
               InItrT& to,
               std::ios_base& a_ios,
               kday_after_type& fka) const
    {
      fka = m_date_gen_parser.get_kday_after_type(from, to, a_ios, *this);
      return from;
    }

  protected:
    string_type m_format;
    string_type m_month_format;
    string_type m_weekday_format;
    string_type m_year_format;
    format_date_parser_type m_parser;
    date_gen_parser_type m_date_gen_parser;
    period_parser_type m_period_parser;
    special_values_parser_type m_sv_parser;
  private:
  };


  template <class date_type, class CharT, class OutItrT>
  std::locale::id date_input_facet<date_type, CharT, OutItrT>::id;

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::long_weekday_format[3] = {'%','A'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::short_weekday_format[3] = {'%','a'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::long_month_format[3] = {'%','B'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::short_month_format[3] = {'%','b'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::four_digit_year_format[3] = {'%','Y'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::two_digit_year_format[3] = {'%','y'};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::default_period_separator[4] = { ' ', '/', ' '};

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::standard_format_specifier[3] =
    {'%', 'x' };

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::iso_format_specifier[7] =
    {'%', 'Y', '%', 'm', '%', 'd' };

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::iso_format_extended_specifier[9] =
    {'%', 'Y', '-', '%', 'm', '-', '%', 'd' };

  template <class date_type, class CharT, class OutItrT>
  const typename date_input_facet<date_type, CharT, OutItrT>::char_type
  date_input_facet<date_type, CharT, OutItrT>::default_date_format[9] =
    {'%','Y','-','%','b','-','%','d'};

} }
# 17 "/usr/include/boost/date_time/gregorian/gregorian_io.hpp" 2 3 4







namespace boost {
namespace gregorian {


  typedef boost::date_time::period_formatter<wchar_t> wperiod_formatter;
  typedef boost::date_time::period_formatter<char> period_formatter;

  typedef boost::date_time::date_facet<date,wchar_t> wdate_facet;
  typedef boost::date_time::date_facet<date,char> date_facet;

  typedef boost::date_time::period_parser<date,char> period_parser;
  typedef boost::date_time::period_parser<date,wchar_t> wperiod_parser;

  typedef boost::date_time::special_values_formatter<char> special_values_formatter;
  typedef boost::date_time::special_values_formatter<wchar_t> wspecial_values_formatter;

  typedef boost::date_time::special_values_parser<date,char> special_values_parser;
  typedef boost::date_time::special_values_parser<date,wchar_t> wspecial_values_parser;

  typedef boost::date_time::date_input_facet<date,char> date_input_facet;
  typedef boost::date_time::date_input_facet<date,wchar_t> wdate_input_facet;

  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date& d) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), d);
    else {







      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), d);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, date& d)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, d);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, d);
        }
      }
      catch(...) {

        std::ios_base::iostate exception_mask = is.exceptions();


        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {

          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }

  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date_duration& dd) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), dd);
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), dd);

    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, date_duration& dd)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dd);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, dd);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }

  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::date_period& dp) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), dp);
    else {







      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), dp);

    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, date_period& dp)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, dp);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, dp);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }



  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::greg_month& gm) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), gm);
    else {
      custom_date_facet* f = new custom_date_facet();

      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), gm);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, greg_month& m)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, m);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, m);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::greg_weekday& gw) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), gw);
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), gw);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, greg_weekday& wd)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, wd);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, wd);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }




  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, greg_day& gd)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gd);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, gd);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }




  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, greg_year& gy)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, gy);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, gy);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }



  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::partial_date& pd) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), pd);
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), pd);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, partial_date& pd)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, pd);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, pd);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }

  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::nth_day_of_the_week_in_month& nkd) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), nkd);
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), nkd);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is,
             nth_day_of_the_week_in_month& nday)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, nday);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, nday);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_in_month& fkd) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fkd);
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), fkd);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is,
             first_day_of_the_week_in_month& fkd)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkd);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, fkd);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::last_day_of_the_week_in_month& lkd) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc()))
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), lkd);
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), lkd);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is,
             last_day_of_the_week_in_month& lkd)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, lkd);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, lkd);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_after& fda) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc())) {
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fda);
    }
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), fda);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is,
             first_day_of_the_week_after& fka)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fka);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, fka);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const boost::gregorian::first_day_of_the_week_before& fdb) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::date_facet<date, CharT> custom_date_facet;
    std::ostreambuf_iterator<CharT> output_itr(os);
    if (std::has_facet<custom_date_facet>(os.getloc())) {
      std::use_facet<custom_date_facet>(os.getloc()).put(output_itr, os, os.fill(), fdb);
    }
    else {
      custom_date_facet* f = new custom_date_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(output_itr, os, os.fill(), fdb);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is,
             first_day_of_the_week_before& fkb)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::date_input_facet<date, CharT> date_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<date_input_facet>(is.getloc())) {
          std::use_facet<date_input_facet>(is.getloc()).get(sit, str_end, is, fkb);
        }
        else {
          date_input_facet* f = new date_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, fkb);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


} }
# 32 "/usr/include/boost/date_time/gregorian/gregorian.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/gregorian/parsers.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/gregorian/parsers.hpp" 3 4
# 1 "/usr/include/boost/date_time/date_parsing.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/date_parsing.hpp" 3 4
# 1 "/usr/include/boost/tokenizer.hpp" 1 3 4
# 20 "/usr/include/boost/tokenizer.hpp" 3 4
# 1 "/usr/include/boost/token_iterator.hpp" 1 3 4
# 21 "/usr/include/boost/token_iterator.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 22 "/usr/include/boost/token_iterator.hpp" 2 3 4

# 1 "/usr/include/boost/iterator/detail/minimum_category.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/detail/minimum_category.hpp" 3 4
namespace boost { namespace detail {
# 23 "/usr/include/boost/iterator/detail/minimum_category.hpp" 3 4
template <bool GreaterEqual, bool LessEqual>
struct minimum_category_impl
# 34 "/usr/include/boost/iterator/detail/minimum_category.hpp" 3 4
;

template <class T1, class T2>
struct error_not_related_by_convertibility;

template <>
struct minimum_category_impl<true,false>
{
    template <class T1, class T2> struct apply
    {
        typedef T2 type;
    };
};

template <>
struct minimum_category_impl<false,true>
{
    template <class T1, class T2> struct apply
    {
        typedef T1 type;
    };
};

template <>
struct minimum_category_impl<true,true>
{
    template <class T1, class T2> struct apply
    {
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_same<T1,T2>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_62;
        typedef T1 type;
    };
};

template <>
struct minimum_category_impl<false,false>
{
    template <class T1, class T2> struct apply
    : error_not_related_by_convertibility<T1,T2>
    {
    };
};

template <class T1 = mpl::_1, class T2 = mpl::_2>
struct minimum_category
{
    typedef minimum_category_impl<



        ::boost::is_convertible<T1,T2>::value
      , ::boost::is_convertible<T2,T1>::value



    > outer;

    typedef typename outer::template apply<T1,T2> inner;
    typedef typename inner::type type;

   
};

template <>
struct minimum_category<mpl::_1,mpl::_2>
{
    template <class T1, class T2>
    struct apply : minimum_category<T1,T2>
    {};

   
};
# 114 "/usr/include/boost/iterator/detail/minimum_category.hpp" 3 4
}}
# 24 "/usr/include/boost/token_iterator.hpp" 2 3 4
# 1 "/usr/include/boost/token_functions.hpp" 1 3 4
# 37 "/usr/include/boost/token_functions.hpp" 3 4
# 1 "/usr/include/c++/4.8/cctype" 1 3 4
# 39 "/usr/include/c++/4.8/cctype" 3 4
       
# 40 "/usr/include/c++/4.8/cctype" 3
# 38 "/usr/include/boost/token_functions.hpp" 2 3 4


# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 41 "/usr/include/boost/token_functions.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/cwctype" 1 3 4
# 39 "/usr/include/c++/4.8/cwctype" 3 4
       
# 40 "/usr/include/c++/4.8/cwctype" 3
# 45 "/usr/include/boost/token_functions.hpp" 2 3 4
# 77 "/usr/include/boost/token_functions.hpp" 3 4
namespace boost{
# 88 "/usr/include/boost/token_functions.hpp" 3 4
  struct escaped_list_error : public std::runtime_error{
    escaped_list_error(const std::string& what_arg):std::runtime_error(what_arg) { }
  };




  template <class Char,
    class Traits = typename std::basic_string<Char>::traits_type >
  class escaped_list_separator {

  private:
    typedef std::basic_string<Char,Traits> string_type;
    struct char_eq {
      Char e_;
      char_eq(Char e):e_(e) { }
      bool operator()(Char c) {
        return Traits::eq(e_,c);
      }
    };
    string_type escape_;
    string_type c_;
    string_type quote_;
    bool last_;

    bool is_escape(Char e) {
      char_eq f(e);
      return std::find_if(escape_.begin(),escape_.end(),f)!=escape_.end();
    }
    bool is_c(Char e) {
      char_eq f(e);
      return std::find_if(c_.begin(),c_.end(),f)!=c_.end();
    }
    bool is_quote(Char e) {
      char_eq f(e);
      return std::find_if(quote_.begin(),quote_.end(),f)!=quote_.end();
    }
    template <typename iterator, typename Token>
    void do_escape(iterator& next,iterator end,Token& tok) {
      if (++next == end)
        throw escaped_list_error(std::string("cannot end with escape"));
      if (Traits::eq(*next,'n')) {
        tok+='\n';
        return;
      }
      else if (is_quote(*next)) {
        tok+=*next;
        return;
      }
      else if (is_c(*next)) {
        tok+=*next;
        return;
      }
      else if (is_escape(*next)) {
        tok+=*next;
        return;
      }
      else
        throw escaped_list_error(std::string("unknown escape sequence"));
    }

    public:

    explicit escaped_list_separator(Char e = '\\',
                                    Char c = ',',Char q = '\"')
      : escape_(1,e), c_(1,c), quote_(1,q), last_(false) { }

    escaped_list_separator(string_type e, string_type c, string_type q)
      : escape_(e), c_(c), quote_(q), last_(false) { }

    void reset() {last_=false;}

    template <typename InputIterator, typename Token>
    bool operator()(InputIterator& next,InputIterator end,Token& tok) {
      bool bInQuote = false;
      tok = Token();

      if (next == end) {
        if (last_) {
          last_ = false;
          return true;
        }
        else
          return false;
      }
      last_ = false;
      for (;next != end;++next) {
        if (is_escape(*next)) {
          do_escape(next,end,tok);
        }
        else if (is_c(*next)) {
          if (!bInQuote) {

            ++next;


            last_ = true;
            return true;
          }
          else tok+=*next;
        }
        else if (is_quote(*next)) {
          bInQuote=!bInQuote;
        }
        else {
          tok += *next;
        }
      }
      return true;
    }
  };





  namespace tokenizer_detail {
# 214 "/usr/include/boost/token_functions.hpp" 3 4
  template<typename traits, int N>
  struct traits_extension_details : public traits {
    typedef typename traits::char_type char_type;
    static bool isspace(char_type c)
    {
       return std::iswspace(c) != 0;
    }
    static bool ispunct(char_type c)
    {
       return std::iswpunct(c) != 0;
    }
  };

  template<typename traits>
  struct traits_extension_details<traits, 1> : public traits {
    typedef typename traits::char_type char_type;
    static bool isspace(char_type c)
    {
       return std::isspace(c) != 0;
    }
    static bool ispunct(char_type c)
    {
       return std::ispunct(c) != 0;
    }
  };





  template<typename traits>
  struct traits_extension : public traits {
    typedef typename traits::char_type char_type;
    static bool isspace(char_type c)
    {

      return traits_extension_details<traits, sizeof(char_type)>::isspace(c);



    }

    static bool ispunct(char_type c)
    {

      return traits_extension_details<traits, sizeof(char_type)>::ispunct(c);



    }
  };
# 277 "/usr/include/boost/token_functions.hpp" 3 4
  template<class IteratorTag>
  struct assign_or_plus_equal {
    template<class Iterator, class Token>
    static void assign(Iterator b, Iterator e, Token &t) {
# 294 "/usr/include/boost/token_functions.hpp" 3 4
      t.assign(b, e);


    }

    template<class Token, class Value>
    static void plus_equal(Token &, const Value &) { }




    template<class Token>
    static void clear(Token &) { }
  };

  template <>
  struct assign_or_plus_equal<std::input_iterator_tag> {
    template<class Iterator, class Token>
    static void assign(Iterator b, Iterator e, Token &t) { }
    template<class Token, class Value>
    static void plus_equal(Token &t, const Value &v) {
      t += v;
    }
    template<class Token>
    static void clear(Token &t) {
      t = Token();
    }
  };


  template<class Iterator>
  struct pointer_iterator_category{
    typedef std::random_access_iterator_tag type;
  };


  template<class Iterator>
  struct class_iterator_category{
    typedef typename Iterator::iterator_category type;
  };




  template<class Iterator>
    struct get_iterator_category{
    typedef typename mpl::if_<is_pointer<Iterator>,
      pointer_iterator_category<Iterator>,
      class_iterator_category<Iterator>
    >::type cat;

    typedef typename cat::type iterator_category;
  };


  }






  class offset_separator {
  private:

    std::vector<int> offsets_;
    unsigned int current_offset_;
    bool wrap_offsets_;
    bool return_partial_last_;

  public:
    template <typename Iter>
    offset_separator(Iter begin, Iter end, bool wrap_offsets = true,
                     bool return_partial_last = true)
      : offsets_(begin,end), current_offset_(0),
        wrap_offsets_(wrap_offsets),
        return_partial_last_(return_partial_last) { }

    offset_separator()
      : offsets_(1,1), current_offset_(),
        wrap_offsets_(true), return_partial_last_(true) { }

    void reset() {
      current_offset_ = 0;
    }

    template <typename InputIterator, typename Token>
    bool operator()(InputIterator& next, InputIterator end, Token& tok)
    {
      typedef tokenizer_detail::assign_or_plus_equal<
        typename tokenizer_detail::get_iterator_category<
          InputIterator
        >::iterator_category
      > assigner;

      ((!offsets_.empty()) ? static_cast<void> (0) : __assert_fail ("!offsets_.empty()", "/usr/include/boost/token_functions.hpp", 389, __PRETTY_FUNCTION__));

      assigner::clear(tok);
      InputIterator start(next);

      if (next == end)
        return false;

      if (current_offset_ == offsets_.size())
      {
        if (wrap_offsets_)
          current_offset_=0;
        else
          return false;
      }

      int c = offsets_[current_offset_];
      int i = 0;
      for (; i < c; ++i) {
        if (next == end)break;
        assigner::plus_equal(tok,*next++);
      }
      assigner::assign(start,next,tok);

      if (!return_partial_last_)
        if (i < (c-1) )
          return false;

      ++current_offset_;
      return true;
    }
  };
# 437 "/usr/include/boost/token_functions.hpp" 3 4
  enum empty_token_policy { drop_empty_tokens, keep_empty_tokens };


  template <typename Char,
    typename Tr = typename std::basic_string<Char>::traits_type >
  class char_separator
  {
    typedef tokenizer_detail::traits_extension<Tr> Traits;
    typedef std::basic_string<Char,Tr> string_type;
  public:
    explicit
    char_separator(const Char* dropped_delims,
                   const Char* kept_delims = 0,
                   empty_token_policy empty_tokens = drop_empty_tokens)
      : m_dropped_delims(dropped_delims),
        m_use_ispunct(false),
        m_use_isspace(false),
        m_empty_tokens(empty_tokens),
        m_output_done(false)
    {

      if (kept_delims)
        m_kept_delims = kept_delims;
    }


    explicit
    char_separator()
      : m_use_ispunct(true),
        m_use_isspace(true),
        m_empty_tokens(drop_empty_tokens) { }

    void reset() { }

    template <typename InputIterator, typename Token>
    bool operator()(InputIterator& next, InputIterator end, Token& tok)
    {
      typedef tokenizer_detail::assign_or_plus_equal<
        typename tokenizer_detail::get_iterator_category<
          InputIterator
        >::iterator_category
      > assigner;

      assigner::clear(tok);


      if (m_empty_tokens == drop_empty_tokens)
        for (; next != end && is_dropped(*next); ++next)
          { }

      InputIterator start(next);

      if (m_empty_tokens == drop_empty_tokens) {

        if (next == end)
          return false;



        if (is_kept(*next)) {
          assigner::plus_equal(tok,*next);
          ++next;
        } else

          for (; next != end && !is_dropped(*next) && !is_kept(*next); ++next)
            assigner::plus_equal(tok,*next);
      }
      else {


        if (next == end)
        {
          if (m_output_done == false)
          {
            m_output_done = true;
            assigner::assign(start,next,tok);
            return true;
          }
          else
            return false;
        }

        if (is_kept(*next)) {
          if (m_output_done == false)
            m_output_done = true;
          else {
            assigner::plus_equal(tok,*next);
            ++next;
            m_output_done = false;
          }
        }
        else if (m_output_done == false && is_dropped(*next)) {
          m_output_done = true;
        }
        else {
          if (is_dropped(*next))
            start=++next;
          for (; next != end && !is_dropped(*next) && !is_kept(*next); ++next)
            assigner::plus_equal(tok,*next);
          m_output_done = true;
        }
      }
      assigner::assign(start,next,tok);
      return true;
    }

  private:
    string_type m_kept_delims;
    string_type m_dropped_delims;
    bool m_use_ispunct;
    bool m_use_isspace;
    empty_token_policy m_empty_tokens;
    bool m_output_done;

    bool is_kept(Char E) const
    {
      if (m_kept_delims.length())
        return m_kept_delims.find(E) != string_type::npos;
      else if (m_use_ispunct) {
        return Traits::ispunct(E) != 0;
      } else
        return false;
    }
    bool is_dropped(Char E) const
    {
      if (m_dropped_delims.length())
        return m_dropped_delims.find(E) != string_type::npos;
      else if (m_use_isspace) {
        return Traits::isspace(E) != 0;
      } else
        return false;
    }
  };
# 582 "/usr/include/boost/token_functions.hpp" 3 4
  template <class Char,
    class Tr = typename std::basic_string<Char>::traits_type >
  class char_delimiters_separator {
  private:

    typedef tokenizer_detail::traits_extension<Tr> Traits;
    typedef std::basic_string<Char,Tr> string_type;
    string_type returnable_;
    string_type nonreturnable_;
    bool return_delims_;
    bool no_ispunct_;
    bool no_isspace_;

    bool is_ret(Char E)const
    {
      if (returnable_.length())
        return returnable_.find(E) != string_type::npos;
      else{
        if (no_ispunct_) {return false;}
        else{
          int r = Traits::ispunct(E);
          return r != 0;
        }
      }
    }
    bool is_nonret(Char E)const
    {
      if (nonreturnable_.length())
        return nonreturnable_.find(E) != string_type::npos;
      else{
        if (no_isspace_) {return false;}
        else{
          int r = Traits::isspace(E);
          return r != 0;
        }
      }
    }

  public:
    explicit char_delimiters_separator(bool return_delims = false,
                                       const Char* returnable = 0,
                                       const Char* nonreturnable = 0)
      : returnable_(returnable ? returnable : string_type().c_str()),
        nonreturnable_(nonreturnable ? nonreturnable:string_type().c_str()),
        return_delims_(return_delims), no_ispunct_(returnable!=0),
        no_isspace_(nonreturnable!=0) { }

    void reset() { }

  public:

     template <typename InputIterator, typename Token>
     bool operator()(InputIterator& next, InputIterator end,Token& tok) {
     tok = Token();



     for (;next!=end && ( is_nonret(*next) || (is_ret(*next)
       && !return_delims_ ) );++next) { }

     if (next == end) {
       return false;
     }



     if (is_ret(*next) && return_delims_) {
       tok+=*next;
       ++next;
     }
     else

       for (;next!=end && !is_nonret(*next) && !is_ret(*next);++next)
         tok+=*next;


     return true;
   }
  };


}
# 25 "/usr/include/boost/token_iterator.hpp" 2 3 4


namespace boost
{
  template <class TokenizerFunc, class Iterator, class Type>
  class token_iterator
      : public iterator_facade<
            token_iterator<TokenizerFunc, Iterator, Type>
          , Type
          , typename detail::minimum_category<
                forward_traversal_tag
              , typename iterator_traversal<Iterator>::type
            >::type
          , const Type&
        >
  {

      friend class iterator_core_access;

      TokenizerFunc f_;
      Iterator begin_;
      Iterator end_;
      bool valid_;
      Type tok_;

      void increment(){
          ((valid_) ? static_cast<void> (0) : __assert_fail ("valid_", "/usr/include/boost/token_iterator.hpp", 51, __PRETTY_FUNCTION__));
          valid_ = f_(begin_,end_,tok_);
      }

      const Type& dereference() const {
          ((valid_) ? static_cast<void> (0) : __assert_fail ("valid_", "/usr/include/boost/token_iterator.hpp", 56, __PRETTY_FUNCTION__));
          return tok_;
      }
      template<class Other>
      bool equal(const Other& a) const{
          return (a.valid_ && valid_)
              ?( (a.begin_==begin_) && (a.end_ == end_) )
              :(a.valid_==valid_);

      }

      void initialize(){
          if(valid_) return;
          f_.reset();
          valid_ = (begin_ != end_)?
              f_(begin_,end_,tok_):false;
      }
  public:
      token_iterator():begin_(),end_(),valid_(false),tok_() { }

      token_iterator(TokenizerFunc f, Iterator begin, Iterator e = Iterator())
          : f_(f),begin_(begin),end_(e),valid_(false),tok_(){ initialize(); }

      token_iterator(Iterator begin, Iterator e = Iterator())
            : f_(),begin_(begin),end_(e),valid_(false),tok_() {initialize();}

      template<class OtherIter>
      token_iterator(
            token_iterator<TokenizerFunc, OtherIter,Type> const& t
            , typename enable_if_convertible<OtherIter, Iterator>::type* = 0)
            : f_(t.tokenizer_function()),begin_(t.base())
            ,end_(t.end()),valid_(!t.at_end()),tok_(t.current_token()) {}

      Iterator base()const{return begin_;}

      Iterator end()const{return end_;};

      TokenizerFunc tokenizer_function()const{return f_;}

      Type current_token()const{return tok_;}

      bool at_end()const{return !valid_;}




  };
    template <
        class TokenizerFunc = char_delimiters_separator<char>,
        class Iterator = std::string::const_iterator,
        class Type = std::string
    >
    class token_iterator_generator {

    private:
    public:
        typedef token_iterator<TokenizerFunc,Iterator,Type> type;
    };




    template<class Type, class Iterator, class TokenizerFunc>
        typename token_iterator_generator<TokenizerFunc,Iterator,Type>::type
    make_token_iterator(Iterator begin, Iterator end,const TokenizerFunc& fun){
        typedef typename
            token_iterator_generator<TokenizerFunc,Iterator,Type>::type ret_type;
        return ret_type(fun,begin,end);
    }

}
# 21 "/usr/include/boost/tokenizer.hpp" 2 3 4

namespace boost {




  template <
    typename TokenizerFunc = char_delimiters_separator<char>,
    typename Iterator = std::string::const_iterator,
    typename Type = std::string
  >
  class tokenizer {
  private:
    typedef token_iterator_generator<TokenizerFunc,Iterator,Type> TGen;




    typedef typename TGen::type iter;

  public:

    typedef iter iterator;
    typedef iter const_iterator;
    typedef Type value_type;
    typedef value_type& reference;
    typedef const value_type& const_reference;
    typedef value_type* pointer;
    typedef const pointer const_pointer;
    typedef void size_type;
    typedef void difference_type;

    tokenizer(Iterator first, Iterator last,
              const TokenizerFunc& f = TokenizerFunc())
      : first_(first), last_(last), f_(f) { }

    template <typename Container>
    tokenizer(const Container& c)
      : first_(c.begin()), last_(c.end()), f_() { }

    template <typename Container>
    tokenizer(const Container& c,const TokenizerFunc& f)
      : first_(c.begin()), last_(c.end()), f_(f) { }

    void assign(Iterator first, Iterator last){
      first_ = first;
      last_ = last;
    }

    void assign(Iterator first, Iterator last, const TokenizerFunc& f){
      assign(first,last);
      f_ = f;
    }

    template <typename Container>
    void assign(const Container& c){
      assign(c.begin(),c.end());
    }


    template <typename Container>
    void assign(const Container& c, const TokenizerFunc& f){
      assign(c.begin(),c.end(),f);
    }

    iter begin() const { return iter(f_,first_,last_); }
    iter end() const { return iter(f_,last_,last_); }

  private:
    Iterator first_;
    Iterator last_;
    TokenizerFunc f_;
  };


}
# 16 "/usr/include/boost/date_time/date_parsing.hpp" 2 3 4
# 26 "/usr/include/boost/date_time/date_parsing.hpp" 3 4
namespace boost {
namespace date_time {







  inline
  std::string
  convert_to_lower(std::string inp)
  {

    const std::locale loc(std::locale::classic());

    std::string::size_type i = 0, n = inp.length();
    for (; i < n; ++i) {
      inp[i] =





        std::tolower(inp[i], loc);

    }
    return inp;
  }




    template<class month_type>
    inline unsigned short
    month_str_to_ushort(std::string const& s) {
      if((s.at(0) >= '0') && (s.at(0) <= '9')) {
        return boost::lexical_cast<unsigned short>(s);
      }
      else {
        std::string str = convert_to_lower(s);
        typename month_type::month_map_ptr_type ptr = month_type::get_month_map_ptr();
        typename month_type::month_map_type::iterator iter = ptr->find(str);
        if(iter != ptr->end()) {
          return iter->second;
        }
      }
      return 13;
    }
# 83 "/usr/include/boost/date_time/date_parsing.hpp" 3 4
    template<class charT>
    short find_match(const charT* const* short_names,
                     const charT* const* long_names,
                     short size,
                     const std::basic_string<charT>& s) {
      for(short i = 0; i < size; ++i){
        if(short_names[i] == s || long_names[i] == s){
          return i;
        }
      }
      return size;
    }







    template<class date_type>
    date_type
    parse_date(const std::string& s, int order_spec = ymd_order_iso) {
      std::string spec_str;
      if(order_spec == ymd_order_iso) {
        spec_str = "ymd";
      }
      else if(order_spec == ymd_order_dmy) {
        spec_str = "dmy";
      }
      else {
        spec_str = "mdy";
      }

      typedef typename date_type::year_type year_type;
      typedef typename date_type::month_type month_type;
      unsigned pos = 0;
      unsigned short year(0), month(0), day(0);
      typedef typename std::basic_string<char>::traits_type traits_type;
      typedef boost::char_separator<char, traits_type> char_separator_type;
      typedef boost::tokenizer<char_separator_type,
                               std::basic_string<char>::const_iterator,
                               std::basic_string<char> > tokenizer;
      typedef boost::tokenizer<char_separator_type,
                               std::basic_string<char>::const_iterator,
                               std::basic_string<char> >::iterator tokenizer_iterator;

      const char sep_char[] = {',','-','.',' ','/','\0'};
      char_separator_type sep(sep_char);
      tokenizer tok(s,sep);
      for(tokenizer_iterator beg=tok.begin();
          beg!=tok.end() && pos < spec_str.size();
          ++beg, ++pos) {
        switch(spec_str.at(pos)) {
          case 'y':
          {
            year = boost::lexical_cast<unsigned short>(*beg);
            break;
          }
          case 'm':
          {
            month = month_str_to_ushort<month_type>(*beg);
            break;
          }
          case 'd':
          {
            day = boost::lexical_cast<unsigned short>(*beg);
            break;
          }
          default: break;
        }
      }
      return date_type(year, month, day);
    }


    template<class date_type>
    date_type
    parse_undelimited_date(const std::string& s) {
      int offsets[] = {4,2,2};
      int pos = 0;
      typedef typename date_type::year_type year_type;

      unsigned short y = 0, m = 0, d = 0;






      boost::offset_separator osf(offsets, offsets+3, false, false);

      typedef typename boost::tokenizer<boost::offset_separator,
                                        std::basic_string<char>::const_iterator,
                                        std::basic_string<char> > tokenizer_type;
      tokenizer_type tok(s, osf);
      for(typename tokenizer_type::iterator ti=tok.begin(); ti!=tok.end();++ti) {
        unsigned short i = boost::lexical_cast<unsigned short>(*ti);
        switch(pos) {
        case 0: y = i; break;
        case 1: m = i; break;
        case 2: d = i; break;
        default: break;
        }
        pos++;
      }
      return date_type(y,m,d);
    }





    template<class date_type, class iterator_type>
    inline
    date_type
    from_stream_type(iterator_type& beg,
                     iterator_type const& end,
                     char)
    {
      std::ostringstream ss;
      while(beg != end) {
        ss << *beg++;
      }
      return parse_date<date_type>(ss.str());
    }




    template<class date_type, class iterator_type>
    inline
    date_type
    from_stream_type(iterator_type& beg,
                     iterator_type const& ,
                     std::string const&)
    {
      return parse_date<date_type>(*beg);
    }







    template<class date_type, class iterator_type>
    inline
    date_type from_stream_type(iterator_type& beg,
                               iterator_type const& end,
                               wchar_t)
    {
      std::ostringstream ss;

      std::locale loc;
      std::ctype<wchar_t> const& fac = std::use_facet<std::ctype<wchar_t> >(loc);
      while(beg != end) {
        ss << fac.narrow(*beg++, 'X');
      }
# 250 "/usr/include/boost/date_time/date_parsing.hpp" 3 4
      return parse_date<date_type>(ss.str());
    }




    template<class date_type, class iterator_type>
    inline
    date_type
    from_stream_type(iterator_type& beg,
                     iterator_type const& ,
                     std::wstring const&) {
      std::wstring ws = *beg;
      std::ostringstream ss;
      std::wstring::iterator wsb = ws.begin(), wse = ws.end();

      std::locale loc;
      std::ctype<wchar_t> const& fac = std::use_facet<std::ctype<wchar_t> >(loc);
      while(wsb != wse) {
        ss << fac.narrow(*wsb++, 'X');
      }
# 280 "/usr/include/boost/date_time/date_parsing.hpp" 3 4
      return parse_date<date_type>(ss.str());
    }





    template<class date_type, class charT>
    period<date_type, typename date_type::duration_type>
    from_simple_string_type(const std::basic_string<charT>& s){
      typedef typename std::basic_string<charT>::traits_type traits_type;
      typedef typename boost::char_separator<charT, traits_type> char_separator;
      typedef typename boost::tokenizer<char_separator,
                                        typename std::basic_string<charT>::const_iterator,
                                        std::basic_string<charT> > tokenizer;
      const charT sep_list[4] = {'[','/',']','\0'};
      char_separator sep(sep_list);
      tokenizer tokens(s, sep);
      typename tokenizer::iterator tok_it = tokens.begin();
      std::basic_string<charT> date_string = *tok_it;

      typename std::basic_string<charT>::iterator date_string_start = date_string.begin(),
                                                  date_string_end = date_string.end();
      typedef typename std::iterator_traits<typename std::basic_string<charT>::iterator>::value_type value_type;
      date_type d1 = from_stream_type<date_type>(date_string_start, date_string_end, value_type());
      date_string = *(++tok_it);
      date_string_start = date_string.begin(), date_string_end = date_string.end();
      date_type d2 = from_stream_type<date_type>(date_string_start, date_string_end, value_type());
      return period<date_type, typename date_type::duration_type>(d1, d2);
    }


} }
# 14 "/usr/include/boost/date_time/gregorian/parsers.hpp" 2 3 4





namespace boost {
namespace gregorian {





  special_values special_value_from_string(const std::string& s);


  inline date from_string(std::string s) {
    return date_time::parse_date<date>(s);
  }


  inline date from_simple_string(std::string s) {
    return date_time::parse_date<date>(s, date_time::ymd_order_iso);
  }


  inline date from_us_string(std::string s) {
    return date_time::parse_date<date>(s, date_time::ymd_order_us);
  }


  inline date from_uk_string(std::string s) {
    return date_time::parse_date<date>(s, date_time::ymd_order_dmy);
  }


  inline date from_undelimited_string(std::string s) {
    return date_time::parse_undelimited_date<date>(s);
  }


  inline date date_from_iso_string(const std::string& s) {
    return date_time::parse_undelimited_date<date>(s);
  }






  template<class iterator_type>
  inline date from_stream(iterator_type beg, iterator_type end) {
    if(beg == end)
    {
      return date(not_a_date_time);
    }
    typedef typename std::iterator_traits<iterator_type>::value_type value_type;
    return date_time::from_stream_type<date>(beg, end, value_type());
  }






  inline date_period date_period_from_string(const std::string& s){
    return date_time::from_simple_string_type<date,char>(s);
  }


  inline date_period date_period_from_wstring(const std::wstring& s){
    return date_time::from_simple_string_type<date,wchar_t>(s);
  }



} }
# 35 "/usr/include/boost/date_time/gregorian/gregorian.hpp" 2 3 4
# 13 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 2 3 4




# 1 "/usr/include/boost/date_time/time_formatting_streams.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/time_formatting_streams.hpp" 3 4
# 1 "/usr/include/boost/date_time/date_formatting_locales.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/date_formatting_locales.hpp" 3 4
# 1 "/usr/include/boost/date_time/date_names_put.hpp" 1 3 4
# 24 "/usr/include/boost/date_time/date_names_put.hpp" 3 4
namespace boost {
namespace date_time {
# 39 "/usr/include/boost/date_time/date_names_put.hpp" 3 4
    template<class Config,
             class charT = char,
             class OutputIterator = std::ostreambuf_iterator<charT> >
    class date_names_put : public std::locale::facet
    {
    public:
      date_names_put() {}
      typedef OutputIterator iter_type;
      typedef typename Config::month_type month_type;
      typedef typename Config::month_enum month_enum;
      typedef typename Config::weekday_enum weekday_enum;
      typedef typename Config::special_value_enum special_value_enum;

      typedef std::basic_string<charT> string_type;
      typedef charT char_type;
      static const char_type default_special_value_names[3][17];
      static const char_type separator[2];

      static std::locale::id id;





      void put_special_value(iter_type& oitr, special_value_enum sv) const
      {
        do_put_special_value(oitr, sv);
      }
      void put_month_short(iter_type& oitr, month_enum moy) const
      {
        do_put_month_short(oitr, moy);
      }
      void put_month_long(iter_type& oitr, month_enum moy) const
      {
        do_put_month_long(oitr, moy);
      }
      void put_weekday_short(iter_type& oitr, weekday_enum wd) const
      {
        do_put_weekday_short(oitr, wd);
      }
      void put_weekday_long(iter_type& oitr, weekday_enum wd) const
      {
        do_put_weekday_long(oitr, wd);
      }
      bool has_date_sep_chars() const
      {
        return do_has_date_sep_chars();
      }
      void year_sep_char(iter_type& oitr) const
      {
        do_year_sep_char(oitr);
      }

      void month_sep_char(iter_type& oitr) const
      {
        do_month_sep_char(oitr);
      }

      void day_sep_char(iter_type& oitr) const
      {
        do_day_sep_char(oitr);
      }

      ymd_order_spec date_order() const
      {
        return do_date_order();
      }

      month_format_spec month_format() const
      {
        return do_month_format();
      }

    protected:

      virtual void do_put_month_short(iter_type& oitr, month_enum moy) const
      {
        month_type gm(moy);
        charT c = '\0';
        put_string(oitr, gm.as_short_string(c));
      }

      virtual void do_put_month_long(iter_type& oitr,
                                     month_enum moy) const
      {
        month_type gm(moy);
        charT c = '\0';
        put_string(oitr, gm.as_long_string(c));
      }

      virtual void do_put_special_value(iter_type& oitr, special_value_enum sv) const
      {
        if(sv <= 2) {
          string_type s(default_special_value_names[sv]);
          put_string(oitr, s);
        }
      }
      virtual void do_put_weekday_short(iter_type&, weekday_enum) const
      {
      }
      virtual void do_put_weekday_long(iter_type&, weekday_enum) const
      {
      }
      virtual bool do_has_date_sep_chars() const
      {
        return true;
      }
      virtual void do_year_sep_char(iter_type& oitr) const
      {
        string_type s(separator);
        put_string(oitr, s);
      }

      virtual void do_month_sep_char(iter_type& oitr) const
      {
        string_type s(separator);
        put_string(oitr, s);
      }

      virtual void do_day_sep_char(iter_type& oitr) const
      {
        string_type s(separator);
        put_string(oitr, s);
      }

      virtual ymd_order_spec do_date_order() const
      {
        return ymd_order_iso;
      }

      virtual month_format_spec do_month_format() const
      {
        return month_as_short_string;
      }
      void put_string(iter_type& oi, const charT* const s) const
      {
        string_type s1(boost::lexical_cast<string_type>(s));
        typename string_type::iterator si,end;
        for (si=s1.begin(), end=s1.end(); si!=end; si++, oi++) {
          *oi = *si;
        }
      }
      void put_string(iter_type& oi, const string_type& s1) const
      {
        typename string_type::const_iterator si,end;
        for (si=s1.begin(), end=s1.end(); si!=end; si++, oi++) {
          *oi = *si;
        }
      }
    };

    template<class Config, class charT, class OutputIterator>
    const typename date_names_put<Config, charT, OutputIterator>::char_type
    date_names_put<Config, charT, OutputIterator>::default_special_value_names[3][17] = {
      {'n','o','t','-','a','-','d','a','t','e','-','t','i','m','e'},
      {'-','i','n','f','i','n','i','t','y'},
      {'+','i','n','f','i','n','i','t','y'} };

    template<class Config, class charT, class OutputIterator>
    const typename date_names_put<Config, charT, OutputIterator>::char_type
    date_names_put<Config, charT, OutputIterator>::separator[2] =
      {'-', '\0'} ;



    template<class Config, class charT, class OutputIterator>
    std::locale::id date_names_put<Config, charT, OutputIterator>::id;


    template<class Config,
             class charT = char,
             class OutputIterator = std::ostreambuf_iterator<charT> >
    class all_date_names_put : public date_names_put<Config, charT, OutputIterator>
    {
    public:
      all_date_names_put(const charT* const month_short_names[],
                         const charT* const month_long_names[],
                         const charT* const special_value_names[],
                         const charT* const weekday_short_names[],
                         const charT* const weekday_long_names[],
                         charT separator_char = '-',
                         ymd_order_spec order_spec = ymd_order_iso,
                         month_format_spec month_format = month_as_short_string) :
        month_short_names_(month_short_names),
        month_long_names_(month_long_names),
        special_value_names_(special_value_names),
        weekday_short_names_(weekday_short_names),
        weekday_long_names_(weekday_long_names),
        order_spec_(order_spec),
        month_format_spec_(month_format)
      {
        separator_char_[0] = separator_char;
        separator_char_[1] = '\0';

      }
      typedef OutputIterator iter_type;
      typedef typename Config::month_enum month_enum;
      typedef typename Config::weekday_enum weekday_enum;
      typedef typename Config::special_value_enum special_value_enum;

      const charT* const* get_short_month_names() const
      {
        return month_short_names_;
      }
      const charT* const* get_long_month_names() const
      {
        return month_long_names_;
      }
      const charT* const* get_special_value_names() const
      {
        return special_value_names_;
      }
      const charT* const* get_short_weekday_names()const
      {
        return weekday_short_names_;
      }
      const charT* const* get_long_weekday_names()const
      {
        return weekday_long_names_;
      }

    protected:

      virtual void do_put_month_short(iter_type& oitr, month_enum moy) const
      {
        this->put_string(oitr, month_short_names_[moy-1]);
      }

      virtual void do_put_month_long(iter_type& oitr, month_enum moy) const
      {
        this->put_string(oitr, month_long_names_[moy-1]);
      }

      virtual void do_put_special_value(iter_type& oitr, special_value_enum sv) const
      {
        this->put_string(oitr, special_value_names_[sv]);
      }
      virtual void do_put_weekday_short(iter_type& oitr, weekday_enum wd) const
      {
        this->put_string(oitr, weekday_short_names_[wd]);
      }
      virtual void do_put_weekday_long(iter_type& oitr, weekday_enum wd) const
      {
        this->put_string(oitr, weekday_long_names_[wd]);
      }

      virtual void do_month_sep_char(iter_type& oitr) const
      {
        this->put_string(oitr, separator_char_);
      }

      virtual void do_day_sep_char(iter_type& oitr) const
      {
        this->put_string(oitr, separator_char_);
      }

      virtual ymd_order_spec do_date_order() const
      {
        return order_spec_;
      }

      virtual month_format_spec do_month_format() const
      {
        return month_format_spec_;
      }

    private:
      const charT* const* month_short_names_;
      const charT* const* month_long_names_;
      const charT* const* special_value_names_;
      const charT* const* weekday_short_names_;
      const charT* const* weekday_long_names_;
      charT separator_char_[2];
      ymd_order_spec order_spec_;
      month_format_spec month_format_spec_;
    };

} }
# 19 "/usr/include/boost/date_time/date_formatting_locales.hpp" 2 3 4






namespace boost {
namespace date_time {


  template<class facet_type,
           class charT = char>
  class ostream_month_formatter
  {
  public:
    typedef typename facet_type::month_type month_type;
    typedef std::basic_ostream<charT> ostream_type;


    static void format_month(const month_type& month,
                             ostream_type& os,
                             const facet_type& f)
    {

      switch (f.month_format())
      {
        case month_as_short_string:
        {
          std::ostreambuf_iterator<charT> oitr(os);
          f.put_month_short(oitr, month.as_enum());
          break;
        }
        case month_as_long_string:
        {
          std::ostreambuf_iterator<charT> oitr(os);
          f.put_month_long(oitr, month.as_enum());
          break;
        }
        case month_as_integer:
        {
          charT fill_char = '0';
          os << std::setw(2) << std::setfill(fill_char) << month.as_number();
          break;
        }

      }
    }

  };



  template<class weekday_type,
           class facet_type,
           class charT = char>
  class ostream_weekday_formatter
  {
  public:
    typedef typename facet_type::month_type month_type;
    typedef std::basic_ostream<charT> ostream_type;


    static void format_weekday(const weekday_type& wd,
                               ostream_type& os,
                               const facet_type& f,
                               bool as_long_string)
    {

      std::ostreambuf_iterator<charT> oitr(os);
      if (as_long_string) {
        f.put_weekday_long(oitr, wd.as_enum());
      }
      else {
        f.put_weekday_short(oitr, wd.as_enum());
      }

    }

  };



  template<class ymd_type,
           class facet_type,
           class charT = char>
  class ostream_ymd_formatter
  {
  public:
    typedef typename ymd_type::month_type month_type;
    typedef ostream_month_formatter<facet_type, charT> month_formatter_type;
    typedef std::basic_ostream<charT> ostream_type;
    typedef std::basic_string<charT> foo_type;
# 131 "/usr/include/boost/date_time/date_formatting_locales.hpp" 3 4
    static void ymd_put(ymd_type ymd,
                        ostream_type& os,
                        const facet_type& f)
    {
      std::ostreambuf_iterator<charT> oitr(os);
      charT fill_char = '0';
      switch (f.date_order()) {
        case ymd_order_iso: {
          os << ymd.year;
          if (f.has_date_sep_chars()) {
            f.month_sep_char(oitr);
          }
          month_formatter_type::format_month(ymd.month, os, f);
          if (f.has_date_sep_chars()) {
            f.day_sep_char(oitr);
          }
          os << std::setw(2) << std::setfill(fill_char)
              << ymd.day;
          break;
        }
        case ymd_order_us: {
          month_formatter_type::format_month(ymd.month, os, f);
          if (f.has_date_sep_chars()) {
          f.day_sep_char(oitr);
          }
          os << std::setw(2) << std::setfill(fill_char)
            << ymd.day;
          if (f.has_date_sep_chars()) {
            f.month_sep_char(oitr);
          }
          os << ymd.year;
          break;
        }
        case ymd_order_dmy: {
          os << std::setw(2) << std::setfill(fill_char)
              << ymd.day;
          if (f.has_date_sep_chars()) {
            f.day_sep_char(oitr);
          }
          month_formatter_type::format_month(ymd.month, os, f);
          if (f.has_date_sep_chars()) {
            f.month_sep_char(oitr);
          }
          os << ymd.year;
          break;
        }
      }
    }
  };



  template<class date_type,
           class facet_type,
           class charT = char>
  class ostream_date_formatter
  {
  public:
    typedef std::basic_ostream<charT> ostream_type;
    typedef typename date_type::ymd_type ymd_type;


    static void date_put(const date_type& d,
                         ostream_type& os,
                         const facet_type& f)
    {
      special_values sv = d.as_special();
      if (sv == not_special) {
        ymd_type ymd = d.year_month_day();
        ostream_ymd_formatter<ymd_type, facet_type, charT>::ymd_put(ymd, os, f);
      }
      else {
        std::ostreambuf_iterator<charT> coi(os);
        f.put_special_value(coi, sv);
      }
    }



    static void date_put(const date_type& d,
                         ostream_type& os)
    {

      std::locale locale = os.getloc();
      if (std::has_facet<facet_type>(locale)) {
        const facet_type& f = std::use_facet<facet_type>(locale);
        date_put(d, os, f);
      }
      else {

        facet_type default_facet;
        date_put(d, os, default_facet);
      }
    }
  };


} }
# 20 "/usr/include/boost/date_time/time_formatting_streams.hpp" 2 3 4


namespace boost {
namespace date_time {



  template<class time_duration_type,
           class charT = char>
  class ostream_time_duration_formatter
  {
  public:
    typedef std::basic_ostream<charT> ostream_type;
    typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;


    static void duration_put(const time_duration_type& td,
                             ostream_type& os)
    {
      if(td.is_special()) {
        os << td.get_rep();
      }
      else {
        charT fill_char = '0';
        if(td.is_negative()) {
          os << '-';
        }
        os << std::setw(2) << std::setfill(fill_char)
            << absolute_value(td.hours()) << ":";
        os << std::setw(2) << std::setfill(fill_char)
            << absolute_value(td.minutes()) << ":";
        os << std::setw(2) << std::setfill(fill_char)
            << absolute_value(td.seconds());
        fractional_seconds_type frac_sec =
          absolute_value(td.fractional_seconds());
        if (frac_sec != 0) {
          os << "."
              << std::setw(time_duration_type::num_fractional_digits())
              << std::setfill(fill_char)
              << frac_sec;
        }
      }
    }
  };


  template<class time_type,
           class charT = char>
  class ostream_time_formatter
  {
  public:
    typedef std::basic_ostream<charT> ostream_type;
    typedef typename time_type::date_type date_type;
    typedef typename time_type::time_duration_type time_duration_type;
    typedef ostream_time_duration_formatter<time_duration_type, charT> duration_formatter;


    static void time_put(const time_type& t,
                         ostream_type& os)
    {
      date_type d = t.date();
      os << d;
      if(!d.is_infinity() && !d.is_not_a_date())
      {
        os << " ";
        duration_formatter::duration_put(t.time_of_day(), os);
      }

    }
  };



  template<class time_period_type,
           class charT = char>
  class ostream_time_period_formatter
  {
  public:
    typedef std::basic_ostream<charT> ostream_type;
    typedef typename time_period_type::point_type time_type;
    typedef ostream_time_formatter<time_type, charT> time_formatter;


    static void period_put(const time_period_type& tp,
                           ostream_type& os)
    {
      os << '[';
      time_formatter::time_put(tp.begin(), os);
      os << '/';
      time_formatter::time_put(tp.last(), os);
      os << ']';

    }

  };



} }
# 18 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/time_parsing.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/time_parsing.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/time_parsing.hpp" 2 3 4


namespace boost {
namespace date_time {




  template<class int_type>
  inline
  int_type power(int_type base, int_type exponent)
  {
    int_type result = 1;
    for(int i = 0; i < exponent; ++i){
      result *= base;
    }
    return result;
  }
# 45 "/usr/include/boost/date_time/time_parsing.hpp" 3 4
  template<class time_duration, class char_type>
  inline
  time_duration
  str_from_delimited_time_duration(const std::basic_string<char_type>& s)
  {
    unsigned short min=0, sec =0;
    int hour =0;
    bool is_neg = (s.at(0) == '-');
    boost::int64_t fs=0;
    int pos = 0;

    typedef typename std::basic_string<char_type>::traits_type traits_type;
    typedef boost::char_separator<char_type, traits_type> char_separator_type;
    typedef boost::tokenizer<char_separator_type,
                             typename std::basic_string<char_type>::const_iterator,
                             std::basic_string<char_type> > tokenizer;
    typedef typename boost::tokenizer<char_separator_type,
                             typename std::basic_string<char_type>::const_iterator,
                             typename std::basic_string<char_type> >::iterator tokenizer_iterator;

    char_type sep_chars[5] = {'-',':',',','.'};
    char_separator_type sep(sep_chars);
    tokenizer tok(s,sep);
    for(tokenizer_iterator beg=tok.begin(); beg!=tok.end();++beg){
      switch(pos) {
      case 0: {
        hour = boost::lexical_cast<int>(*beg);
        break;
      }
      case 1: {
        min = boost::lexical_cast<unsigned short>(*beg);
        break;
      }
      case 2: {
        sec = boost::lexical_cast<unsigned short>(*beg);
        break;
      };
      case 3: {
        int digits = static_cast<int>(beg->length());
# 101 "/usr/include/boost/date_time/time_parsing.hpp" 3 4
        int precision = time_duration::num_fractional_digits();
        if(digits >= precision) {

          fs = boost::lexical_cast<boost::int64_t>(beg->substr(0, precision));
        }
        else {
          fs = boost::lexical_cast<boost::int64_t>(*beg);
        }

        if(digits < precision){



          fs *= power(10, precision - digits);
        }

        break;
      }
      default: break;
      }
      pos++;
    }
    if(is_neg) {
      return -time_duration(hour, min, sec, fs);
    }
    else {
      return time_duration(hour, min, sec, fs);
    }
  }
# 141 "/usr/include/boost/date_time/time_parsing.hpp" 3 4
  template<class time_duration>
  inline
  time_duration
  parse_delimited_time_duration(const std::string& s)
  {
    return str_from_delimited_time_duration<time_duration,char>(s);
  }


  inline
  bool
  split(const std::string& s,
        char sep,
        std::string& first,
        std::string& second)
  {
    std::string::size_type sep_pos = s.find(sep);
    first = s.substr(0,sep_pos);
    if (sep_pos!=std::string::npos)
        second = s.substr(sep_pos+1);
    return true;
  }


  template<class time_type>
  inline
  time_type
  parse_delimited_time(const std::string& s, char sep)
  {
    typedef typename time_type::time_duration_type time_duration;
    typedef typename time_type::date_type date_type;


    std::string date_string, tod_string;
    split(s, sep, date_string, tod_string);

    date_type d = parse_date<date_type>(date_string);

    time_duration td = parse_delimited_time_duration<time_duration>(tod_string);

    return time_type(d, td);

  }


  template<class time_duration>
  inline
  time_duration
  parse_undelimited_time_duration(const std::string& s)
  {
    int precision = 0;
    {



      time_duration tmp(0,0,0,1);
      precision = tmp.num_fractional_digits();
    }

    int offsets[] = {2,2,2, precision+1};
    int pos = 0, sign = 0;
    int hours = 0;
    short min=0, sec=0;
    boost::int64_t fs=0;

    if(s.at(sign) == '-')
    {
      ++sign;
    }


    std::string remain = s.substr(sign);





    bool wrap_off = false;
    bool ret_part = true;
    boost::offset_separator osf(offsets, offsets+4, wrap_off, ret_part);
    typedef boost::tokenizer<boost::offset_separator,
                             std::basic_string<char>::const_iterator,
                             std::basic_string<char> > tokenizer;
    typedef boost::tokenizer<boost::offset_separator,
                             std::basic_string<char>::const_iterator,
                             std::basic_string<char> >::iterator tokenizer_iterator;
    tokenizer tok(remain, osf);
    for(tokenizer_iterator ti=tok.begin(); ti!=tok.end();++ti){
      switch(pos) {
        case 0:
          {
            hours = boost::lexical_cast<int>(*ti);
            break;
          }
        case 1:
          {
            min = boost::lexical_cast<short>(*ti);
            break;
          }
        case 2:
          {
            sec = boost::lexical_cast<short>(*ti);
            break;
          }
        case 3:
          {
            std::string char_digits(ti->substr(1));
            int digits = static_cast<int>(char_digits.length());
# 265 "/usr/include/boost/date_time/time_parsing.hpp" 3 4
            if(digits >= precision) {

              fs = boost::lexical_cast<boost::int64_t>(char_digits.substr(0, precision));
            }
            else if(digits == 0) {
              fs = 0;
            }
            else {
              fs = boost::lexical_cast<boost::int64_t>(char_digits);
            }

            if(digits < precision){



              fs *= power(10, precision - digits);
            }

            break;
          }
          default: break;
      };
      pos++;
    }
    if(sign) {
      return -time_duration(hours, min, sec, fs);
    }
    else {
      return time_duration(hours, min, sec, fs);
    }
  }


  template<class time_type>
  inline
  time_type
  parse_iso_time(const std::string& s, char sep)
  {
    typedef typename time_type::time_duration_type time_duration;
    typedef typename time_type::date_type date_type;


    std::string date_string, tod_string;
    split(s, sep, date_string, tod_string);

    date_type d = parse_undelimited_date<date_type>(date_string);

    time_duration td = parse_undelimited_time_duration<time_duration>(tod_string);

    return time_type(d, td);
  }



} }
# 20 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 2 3 4






namespace boost {

namespace posix_time {



  template<class charT>
  inline std::basic_string<charT> to_simple_string_type(time_duration td) {
    std::basic_ostringstream<charT> ss;
    if(td.is_special()) {



      switch(td.get_rep().as_special())
      {
      case not_a_date_time:

        ss << "not-a-date-time";
        break;
      case pos_infin:
        ss << "+infinity";
        break;
      case neg_infin:
        ss << "-infinity";
        break;
      default:
        ss << "";
      }
    }
    else {
      charT fill_char = '0';
      if(td.is_negative()) {
        ss << '-';
      }
      ss << std::setw(2) << std::setfill(fill_char)
          << date_time::absolute_value(td.hours()) << ":";
      ss << std::setw(2) << std::setfill(fill_char)
          << date_time::absolute_value(td.minutes()) << ":";
      ss << std::setw(2) << std::setfill(fill_char)
          << date_time::absolute_value(td.seconds());
# 74 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 3 4
      time_duration::fractional_seconds_type frac_sec =
        date_time::absolute_value(td.fractional_seconds());

      if (frac_sec != 0) {
        ss << "." << std::setw(time_duration::num_fractional_digits())
            << std::setfill(fill_char)





        << frac_sec;

      }
    }
    return ss.str();
  }



  inline std::string to_simple_string(time_duration td) {
    return to_simple_string_type<char>(td);
  }




  template<class charT>
  inline std::basic_string<charT> to_iso_string_type(time_duration td)
  {
    std::basic_ostringstream<charT> ss;
    if(td.is_special()) {



      switch(td.get_rep().as_special()) {
      case not_a_date_time:

        ss << "not-a-date-time";
        break;
      case pos_infin:
        ss << "+infinity";
        break;
      case neg_infin:
        ss << "-infinity";
        break;
      default:
        ss << "";
      }
    }
    else {
      charT fill_char = '0';
      if(td.is_negative()) {
        ss << '-';
      }
      ss << std::setw(2) << std::setfill(fill_char)
          << date_time::absolute_value(td.hours());
      ss << std::setw(2) << std::setfill(fill_char)
          << date_time::absolute_value(td.minutes());
      ss << std::setw(2) << std::setfill(fill_char)
          << date_time::absolute_value(td.seconds());
# 143 "/usr/include/boost/date_time/posix_time/time_formatters.hpp" 3 4
      time_duration::fractional_seconds_type frac_sec =
        date_time::absolute_value(td.fractional_seconds());

      if (frac_sec != 0) {
        ss << "." << std::setw(time_duration::num_fractional_digits())
            << std::setfill(fill_char)





        << frac_sec;

      }
    }
    return ss.str();
  }



  inline std::string to_iso_string(time_duration td){
    return to_iso_string_type<char>(td);
  }




  template<class charT>
  inline std::basic_string<charT> to_simple_string_type(ptime t)
  {

    std::basic_string<charT> ts = gregorian::to_simple_string_type<charT>(t.date());
    if(!t.time_of_day().is_special()) {
      charT space = ' ';
      return ts + space + to_simple_string_type<charT>(t.time_of_day());
    }
    else {
      return ts;
    }
  }
  inline std::string to_simple_string(ptime t){
    return to_simple_string_type<char>(t);
  }



  template<class charT>
  inline std::basic_string<charT> to_simple_string_type(time_period tp)
  {
    charT beg = '[', mid = '/', end = ']';
    std::basic_string<charT> d1(to_simple_string_type<charT>(tp.begin()));
    std::basic_string<charT> d2(to_simple_string_type<charT>(tp.last()));
    return std::basic_string<charT>(beg + d1 + mid + d2 + end);
  }



  inline std::string to_simple_string(time_period tp){
    return to_simple_string_type<char>(tp);
  }



  template<class charT>
  inline std::basic_string<charT> to_iso_string_type(ptime t)
  {
    std::basic_string<charT> ts = gregorian::to_iso_string_type<charT>(t.date());
    if(!t.time_of_day().is_special()) {
      charT sep = 'T';
      return ts + sep + to_iso_string_type<charT>(t.time_of_day());
    }
    else {
      return ts;
    }
  }



  inline std::string to_iso_string(ptime t){
    return to_iso_string_type<char>(t);
  }




  template<class charT>
  inline std::basic_string<charT> to_iso_extended_string_type(ptime t)
  {
    std::basic_string<charT> ts = gregorian::to_iso_extended_string_type<charT>(t.date());
    if(!t.time_of_day().is_special()) {
      charT sep = 'T';
      return ts + sep + to_simple_string_type<charT>(t.time_of_day());
    }
    else {
      return ts;
    }
  }



  inline std::string to_iso_extended_string(ptime t){
    return to_iso_extended_string_type<char>(t);
  }





  inline std::wstring to_simple_wstring(time_duration td) {
    return to_simple_string_type<wchar_t>(td);
  }



  inline std::wstring to_iso_wstring(time_duration td){
    return to_iso_string_type<wchar_t>(td);
  }
    inline std::wstring to_simple_wstring(ptime t){
    return to_simple_string_type<wchar_t>(t);
  }



  inline std::wstring to_simple_wstring(time_period tp){
    return to_simple_string_type<wchar_t>(tp);
  }



  inline std::wstring to_iso_wstring(ptime t){
    return to_iso_string_type<wchar_t>(t);
  }



  inline std::wstring to_iso_extended_wstring(ptime t){
    return to_iso_extended_string_type<wchar_t>(t);
  }




} }
# 25 "/usr/include/boost/date_time/posix_time/posix_time.hpp" 2 3 4






# 1 "/usr/include/boost/date_time/posix_time/posix_time_io.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/posix_time/posix_time_io.hpp" 3 4
# 1 "/usr/include/boost/date_time/time_facet.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/time_facet.hpp" 3 4
# 1 "/usr/include/c++/4.8/cctype" 1 3 4
# 39 "/usr/include/c++/4.8/cctype" 3 4
       
# 40 "/usr/include/c++/4.8/cctype" 3
# 14 "/usr/include/boost/date_time/time_facet.hpp" 2 3 4







# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 22 "/usr/include/boost/date_time/time_facet.hpp" 2 3 4
# 33 "/usr/include/boost/date_time/time_facet.hpp" 3 4
namespace boost {
namespace date_time {

  template <class CharT>
  struct time_formats {
    public:
      typedef CharT char_type;
      static const char_type fractional_seconds_format[3];
      static const char_type fractional_seconds_or_none_format[3];
      static const char_type seconds_with_fractional_seconds_format[3];
      static const char_type seconds_format[3];
      static const char_type hours_format[3];
      static const char_type unrestricted_hours_format[3];
      static const char_type full_24_hour_time_format[3];
      static const char_type full_24_hour_time_expanded_format[9];
      static const char_type short_24_hour_time_format[3];
      static const char_type short_24_hour_time_expanded_format[6];
      static const char_type standard_format[9];
      static const char_type zone_abbrev_format[3];
      static const char_type zone_name_format[3];
      static const char_type zone_iso_format[3];
      static const char_type zone_iso_extended_format[3];
      static const char_type posix_zone_string_format[4];
      static const char_type duration_sign_negative_only[3];
      static const char_type duration_sign_always[3];
      static const char_type duration_seperator[2];
      static const char_type negative_sign[2];
      static const char_type positive_sign[2];
      static const char_type iso_time_format_specifier[18];
      static const char_type iso_time_format_extended_specifier[22];

      static const char_type default_time_format[23];

      static const char_type default_time_input_format[24];

      static const char_type default_time_duration_format[11];
  };

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::fractional_seconds_format[3] = {'%','f'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::fractional_seconds_or_none_format[3] = {'%','F'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::seconds_with_fractional_seconds_format[3] = {'%','s'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::seconds_format[3] = {'%','S'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::hours_format[3] = {'%','H'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::unrestricted_hours_format[3] = {'%','O'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::full_24_hour_time_format[3] = {'%','T'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::full_24_hour_time_expanded_format[9] =
  {'%','H',':','%','M',':','%','S'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::short_24_hour_time_format[3] = {'%','R'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::short_24_hour_time_expanded_format[6] =
  {'%','H',':','%','M'};

  template <class CharT>
  const typename time_formats<CharT>::char_type

  time_formats<CharT>::standard_format[9] = {'%','x',' ','%','X',' ','%','z'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::zone_abbrev_format[3] = {'%','z'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::zone_name_format[3] = {'%','Z'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::zone_iso_format[3] = {'%','q'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::zone_iso_extended_format[3] ={'%','Q'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::posix_zone_string_format[4] ={'%','Z','P'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::duration_seperator[2] = {':'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::negative_sign[2] = {'-'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::positive_sign[2] = {'+'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::duration_sign_negative_only[3] ={'%','-'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::duration_sign_always[3] ={'%','+'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::iso_time_format_specifier[18] =
    {'%', 'Y', '%', 'm', '%', 'd', 'T',
     '%', 'H', '%', 'M', '%', 'S', '%', 'F', '%','q' };

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::iso_time_format_extended_specifier[22] =
    {'%', 'Y', '-', '%', 'm', '-', '%', 'd', ' ',
     '%', 'H', ':', '%', 'M', ':', '%', 'S', '%', 'F','%','Q'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::default_time_format[23] =
    {'%','Y','-','%','b','-','%','d',' ',
      '%','H',':','%','M',':','%','S','%','F',' ','%','z'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::default_time_input_format[24] =
    {'%','Y','-','%','b','-','%','d',' ',
      '%','H',':','%','M',':','%','S','%','F',' ','%','Z','P'};

  template <class CharT>
  const typename time_formats<CharT>::char_type
  time_formats<CharT>::default_time_duration_format[11] =
    {'%','O',':','%','M',':','%','S','%','F'};
# 200 "/usr/include/boost/date_time/time_facet.hpp" 3 4
  template <class time_type,
            class CharT,
            class OutItrT = std::ostreambuf_iterator<CharT, std::char_traits<CharT> > >
  class time_facet :
    public boost::date_time::date_facet<typename time_type::date_type , CharT, OutItrT> {
    typedef time_formats< CharT > formats_type;
   public:
    typedef typename time_type::date_type date_type;
    typedef typename time_type::time_duration_type time_duration_type;
    typedef boost::date_time::period<time_type,time_duration_type> period_type;
    typedef boost::date_time::date_facet<typename time_type::date_type, CharT, OutItrT> base_type;
    typedef typename base_type::string_type string_type;
    typedef typename base_type::char_type char_type;
    typedef typename base_type::period_formatter_type period_formatter_type;
    typedef typename base_type::special_values_formatter_type special_values_formatter_type;
    typedef typename base_type::date_gen_formatter_type date_gen_formatter_type;
    static const char_type* fractional_seconds_format;
    static const char_type* fractional_seconds_or_none_format;
    static const char_type* seconds_with_fractional_seconds_format;
    static const char_type* seconds_format;
    static const char_type* hours_format;
    static const char_type* unrestricted_hours_format;
    static const char_type* standard_format;
    static const char_type* zone_abbrev_format;
    static const char_type* zone_name_format;
    static const char_type* zone_iso_format;
    static const char_type* zone_iso_extended_format;
    static const char_type* posix_zone_string_format;
    static const char_type* duration_seperator;
    static const char_type* duration_sign_always;
    static const char_type* duration_sign_negative_only;
    static const char_type* negative_sign;
    static const char_type* positive_sign;
    static const char_type* iso_time_format_specifier;
    static const char_type* iso_time_format_extended_specifier;


    static const char_type* default_time_format;

    static const char_type* default_time_duration_format;
    static std::locale::id id;






    explicit time_facet(::size_t ref_arg = 0)
      : base_type(default_time_format, period_formatter_type(), special_values_formatter_type(), date_gen_formatter_type(), ref_arg),
        m_time_duration_format(string_type(duration_sign_negative_only) + default_time_duration_format)
    {}


    explicit time_facet(const char_type* format_arg,
                        period_formatter_type period_formatter_arg = period_formatter_type(),
                        const special_values_formatter_type& special_value_formatter = special_values_formatter_type(),
                        date_gen_formatter_type dg_formatter = date_gen_formatter_type(),
                         ::size_t ref_arg = 0)
      : base_type(format_arg,
                  period_formatter_arg,
                  special_value_formatter,
                  dg_formatter,
                  ref_arg),
        m_time_duration_format(string_type(duration_sign_negative_only) + default_time_duration_format)
    {}


    void time_duration_format(const char_type* const format)
    {
      m_time_duration_format = format;
    }

    virtual void set_iso_format()
    {
      this->m_format = iso_time_format_specifier;
    }
    virtual void set_iso_extended_format()
    {
      this->m_format = iso_time_format_extended_specifier;
    }

    OutItrT put(OutItrT next_arg,
                std::ios_base& ios_arg,
                char_type fill_arg,
                const time_type& time_arg) const
    {
      if (time_arg.is_special()) {
        return this->do_put_special(next_arg, ios_arg, fill_arg,
                              time_arg.date().as_special());
      }
      string_type local_format(this->m_format);


      boost::algorithm::replace_all(local_format,
        boost::as_literal(formats_type::full_24_hour_time_format),
        boost::as_literal(formats_type::full_24_hour_time_expanded_format));
      boost::algorithm::replace_all(local_format,
        boost::as_literal(formats_type::short_24_hour_time_format),
        boost::as_literal(formats_type::short_24_hour_time_expanded_format));

      string_type frac_str;
      if (local_format.find(seconds_with_fractional_seconds_format) != string_type::npos) {

        frac_str =
          fractional_seconds_as_string(time_arg.time_of_day(), false);
        char_type sep = std::use_facet<std::numpunct<char_type> >(ios_arg.getloc()).decimal_point();

        string_type replace_string(seconds_format);
        replace_string += sep;
        replace_string += frac_str;
        boost::algorithm::replace_all(local_format,
                                      seconds_with_fractional_seconds_format,
                                      replace_string);
      }



      if (local_format.find(posix_zone_string_format) != string_type::npos) {
        if(time_arg.zone_abbrev().empty()) {


          boost::algorithm::erase_all(local_format, posix_zone_string_format);
        }
        else{
          boost::algorithm::replace_all(local_format,
                                        posix_zone_string_format,
                                        time_arg.zone_as_posix_string());
        }
      }
      if (local_format.find(zone_name_format) != string_type::npos) {
        if(time_arg.zone_name().empty()) {






          std::basic_ostringstream<char_type> ss;
          ss << ' ' << zone_name_format;
          boost::algorithm::erase_all(local_format, ss.str());
        }
        else{
          boost::algorithm::replace_all(local_format,
                                        zone_name_format,
                                        time_arg.zone_name());
        }
      }
      if (local_format.find(zone_abbrev_format) != string_type::npos) {
        if(time_arg.zone_abbrev(false).empty()) {






          std::basic_ostringstream<char_type> ss;
          ss << ' ' << zone_abbrev_format;
          boost::algorithm::erase_all(local_format, ss.str());
        }
        else{
          boost::algorithm::replace_all(local_format,
                                        zone_abbrev_format,
                                        time_arg.zone_abbrev(false));
        }
      }
      if (local_format.find(zone_iso_extended_format) != string_type::npos) {
        if(time_arg.zone_name(true).empty()) {






          boost::algorithm::erase_all(local_format, zone_iso_extended_format);
        }
        else{
          boost::algorithm::replace_all(local_format,
                                        zone_iso_extended_format,
                                        time_arg.zone_name(true));
        }
      }

      if (local_format.find(zone_iso_format) != string_type::npos) {
        if(time_arg.zone_abbrev(true).empty()) {






          boost::algorithm::erase_all(local_format, zone_iso_format);
        }
        else{
          boost::algorithm::replace_all(local_format,
                                        zone_iso_format,
                                        time_arg.zone_abbrev(true));
        }
      }
      if (local_format.find(fractional_seconds_format) != string_type::npos) {

        if (frac_str.empty()) {
          frac_str = fractional_seconds_as_string(time_arg.time_of_day(), false);
        }
        boost::algorithm::replace_all(local_format,
                                      fractional_seconds_format,
                                      frac_str);
      }

      if (local_format.find(fractional_seconds_or_none_format) != string_type::npos) {

        frac_str =
          fractional_seconds_as_string(time_arg.time_of_day(), true);
        if (frac_str.size()) {
          char_type sep = std::use_facet<std::numpunct<char_type> >(ios_arg.getloc()).decimal_point();
          string_type replace_string;
          replace_string += sep;
          replace_string += frac_str;
          boost::algorithm::replace_all(local_format,
                                        fractional_seconds_or_none_format,
                                        replace_string);
        }
        else {
          boost::algorithm::erase_all(local_format,
                                      fractional_seconds_or_none_format);
        }
      }

      return this->do_put_tm(next_arg, ios_arg, fill_arg,
                       to_tm(time_arg), local_format);
    }


    OutItrT put(OutItrT next_arg,
                std::ios_base& ios_arg,
                char_type fill_arg,
                const time_duration_type& time_dur_arg) const
    {
      if (time_dur_arg.is_special()) {
        return this->do_put_special(next_arg, ios_arg, fill_arg,
                              time_dur_arg.get_rep().as_special());
      }

      string_type format(m_time_duration_format);
      if (time_dur_arg.is_negative()) {

        boost::algorithm::replace_all(format,
                                      duration_sign_negative_only,
                                      negative_sign);

        boost::algorithm::replace_all(format,
                                      duration_sign_always,
                                      negative_sign);
      }
      else {

        boost::algorithm::erase_all(format, duration_sign_negative_only);

        boost::algorithm::replace_all(format,
                                      duration_sign_always,
                                      positive_sign);
      }


      boost::algorithm::replace_all(format,
        boost::as_literal(formats_type::full_24_hour_time_format),
        boost::as_literal(formats_type::full_24_hour_time_expanded_format));
      boost::algorithm::replace_all(format,
        boost::as_literal(formats_type::short_24_hour_time_format),
        boost::as_literal(formats_type::short_24_hour_time_expanded_format));
# 478 "/usr/include/boost/date_time/time_facet.hpp" 3 4
      string_type hours_str;
      if (format.find(unrestricted_hours_format) != string_type::npos) {
        hours_str = hours_as_string(time_dur_arg);
        boost::algorithm::replace_all(format, unrestricted_hours_format, hours_str);
      }



      if (format.find(hours_format) != string_type::npos) {
        if (hours_str.empty())
          hours_str = hours_as_string(time_dur_arg);
        ((hours_str.length() <= 2) ? static_cast<void> (0) : __assert_fail ("hours_str.length() <= 2", "/usr/include/boost/date_time/time_facet.hpp", 489, __PRETTY_FUNCTION__));
        boost::algorithm::replace_all(format, hours_format, hours_str);
      }

      string_type frac_str;
      if (format.find(seconds_with_fractional_seconds_format) != string_type::npos) {

        frac_str =
          fractional_seconds_as_string(time_dur_arg, false);
        char_type sep = std::use_facet<std::numpunct<char_type> >(ios_arg.getloc()).decimal_point();

        string_type replace_string(seconds_format);
        replace_string += sep;
        replace_string += frac_str;
        boost::algorithm::replace_all(format,
                                      seconds_with_fractional_seconds_format,
                                      replace_string);
      }
      if (format.find(fractional_seconds_format) != string_type::npos) {

        if (!frac_str.size()) {
          frac_str = fractional_seconds_as_string(time_dur_arg, false);
        }
        boost::algorithm::replace_all(format,
                                      fractional_seconds_format,
                                      frac_str);
      }

      if (format.find(fractional_seconds_or_none_format) != string_type::npos) {

        frac_str =
          fractional_seconds_as_string(time_dur_arg, true);
        if (frac_str.size()) {
          char_type sep = std::use_facet<std::numpunct<char_type> >(ios_arg.getloc()).decimal_point();
          string_type replace_string;
          replace_string += sep;
          replace_string += frac_str;
          boost::algorithm::replace_all(format,
                                        fractional_seconds_or_none_format,
                                        replace_string);
        }
        else {
          boost::algorithm::erase_all(format,
                                      fractional_seconds_or_none_format);
        }
      }

      return this->do_put_tm(next_arg, ios_arg, fill_arg,
                       to_tm(time_dur_arg), format);
    }

    OutItrT put(OutItrT next, std::ios_base& ios_arg,
                char_type fill, const period_type& p) const
    {
      return this->m_period_formatter.put_period(next, ios_arg, fill,p,*this);
    }


  protected:

    static
    string_type
    fractional_seconds_as_string(const time_duration_type& time_arg,
                                 bool null_when_zero)
    {
      typename time_duration_type::fractional_seconds_type frac_sec =
        time_arg.fractional_seconds();

      if (null_when_zero && (frac_sec == 0)) {
        return string_type();
      }


      return integral_as_string(
        date_time::absolute_value(frac_sec),
        time_duration_type::num_fractional_digits());
    }

    static
    string_type
    hours_as_string(const time_duration_type& time_arg, int width = 2)
    {
      return integral_as_string(date_time::absolute_value(time_arg.hours()), width);
    }

    template< typename IntT >
    static
    string_type
    integral_as_string(IntT val, int width = 2)
    {
      std::basic_ostringstream<char_type> ss;
      ss.imbue(std::locale::classic());
      ss << std::setw(width)
        << std::setfill(static_cast<char_type>('0'));





      ss << val;

      return ss.str();
    }

  private:
    string_type m_time_duration_format;

  };

  template <class time_type, class CharT, class OutItrT>
  std::locale::id time_facet<time_type, CharT, OutItrT>::id;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::fractional_seconds_format = time_formats<CharT>::fractional_seconds_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::fractional_seconds_or_none_format = time_formats<CharT>::fractional_seconds_or_none_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::seconds_with_fractional_seconds_format =
    time_formats<CharT>::seconds_with_fractional_seconds_format;


  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::zone_name_format = time_formats<CharT>::zone_name_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::zone_abbrev_format = time_formats<CharT>::zone_abbrev_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::zone_iso_extended_format =time_formats<CharT>::zone_iso_extended_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::posix_zone_string_format =time_formats<CharT>::posix_zone_string_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::zone_iso_format = time_formats<CharT>::zone_iso_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::seconds_format = time_formats<CharT>::seconds_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::hours_format = time_formats<CharT>::hours_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::unrestricted_hours_format = time_formats<CharT>::unrestricted_hours_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::standard_format = time_formats<CharT>::standard_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::duration_seperator = time_formats<CharT>::duration_seperator;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::negative_sign = time_formats<CharT>::negative_sign;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::positive_sign = time_formats<CharT>::positive_sign;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::duration_sign_negative_only = time_formats<CharT>::duration_sign_negative_only;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::duration_sign_always = time_formats<CharT>::duration_sign_always;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type,CharT, OutItrT>::char_type*
  time_facet<time_type,CharT, OutItrT>::iso_time_format_specifier = time_formats<CharT>::iso_time_format_specifier;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::iso_time_format_extended_specifier = time_formats<CharT>::iso_time_format_extended_specifier;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::default_time_format =
    time_formats<CharT>::default_time_format;

  template <class time_type, class CharT, class OutItrT>
  const typename time_facet<time_type, CharT, OutItrT>::char_type*
  time_facet<time_type, CharT, OutItrT>::default_time_duration_format =
    time_formats<CharT>::default_time_duration_format;





  template <class time_type,
            class CharT,
            class InItrT = std::istreambuf_iterator<CharT, std::char_traits<CharT> > >
  class time_input_facet :
    public boost::date_time::date_input_facet<typename time_type::date_type , CharT, InItrT> {
    public:
      typedef typename time_type::date_type date_type;
      typedef typename time_type::time_duration_type time_duration_type;
      typedef typename time_duration_type::fractional_seconds_type fracional_seconds_type;
      typedef boost::date_time::period<time_type,time_duration_type> period_type;
      typedef boost::date_time::date_input_facet<typename time_type::date_type, CharT, InItrT> base_type;
      typedef typename base_type::duration_type date_duration_type;
      typedef typename base_type::year_type year_type;
      typedef typename base_type::month_type month_type;
      typedef typename base_type::day_type day_type;
      typedef typename base_type::string_type string_type;
      typedef typename string_type::const_iterator const_itr;
      typedef typename base_type::char_type char_type;
      typedef typename base_type::format_date_parser_type format_date_parser_type;
      typedef typename base_type::period_parser_type period_parser_type;
      typedef typename base_type::special_values_parser_type special_values_parser_type;
      typedef typename base_type::date_gen_parser_type date_gen_parser_type;
      typedef typename base_type::special_values_parser_type::match_results match_results;

      static const char_type* fractional_seconds_format;
      static const char_type* fractional_seconds_or_none_format;
      static const char_type* seconds_with_fractional_seconds_format;
      static const char_type* seconds_format;
      static const char_type* standard_format;
      static const char_type* zone_abbrev_format;
      static const char_type* zone_name_format;
      static const char_type* zone_iso_format;
      static const char_type* zone_iso_extended_format;
      static const char_type* duration_seperator;
      static const char_type* iso_time_format_specifier;
      static const char_type* iso_time_format_extended_specifier;
      static const char_type* default_time_input_format;
      static const char_type* default_time_duration_format;
      static std::locale::id id;


      explicit time_input_facet(const string_type& format, ::size_t ref_arg = 0)
        : base_type(format, ref_arg),
          m_time_duration_format(default_time_duration_format)
      { }

      explicit time_input_facet(const string_type& format,
                                const format_date_parser_type& date_parser,
                                const special_values_parser_type& sv_parser,
                                const period_parser_type& per_parser,
                                const date_gen_parser_type& date_gen_parser,
                                ::size_t ref_arg = 0)
        : base_type(format,
                    date_parser,
                    sv_parser,
                    per_parser,
                    date_gen_parser,
                    ref_arg),
          m_time_duration_format(default_time_duration_format)
      {}


      explicit time_input_facet(::size_t ref_arg = 0)
        : base_type(default_time_input_format, ref_arg),
          m_time_duration_format(default_time_duration_format)
      { }


      void time_duration_format(const char_type* const format) {
        m_time_duration_format = format;
      }
      virtual void set_iso_format()
      {
        this->m_format = iso_time_format_specifier;
      }
      virtual void set_iso_extended_format()
      {
        this->m_format = iso_time_format_extended_specifier;
      }

      InItrT get(InItrT& sitr,
                 InItrT& stream_end,
                 std::ios_base& ios_arg,
                 period_type& p) const
      {
        p = this->m_period_parser.get_period(sitr,
                                             stream_end,
                                             ios_arg,
                                             p,
                                             time_duration_type::unit(),
                                             *this);
        return sitr;
      }




      InItrT get(InItrT& sitr,
                 InItrT& stream_end,
                 std::ios_base& ios_arg,
                 time_duration_type& td) const
      {

        while((sitr != stream_end) && std::isspace(*sitr)) { ++sitr; }

        bool use_current_char = false;


        char_type c = '\0';
        if((sitr != stream_end) && (*sitr == '-' || *sitr == '+')) {
          c = *sitr;
        }

        typedef typename time_duration_type::hour_type hour_type;
        typedef typename time_duration_type::min_type min_type;
        typedef typename time_duration_type::sec_type sec_type;

        hour_type hour = 0;
        min_type min = 0;
        sec_type sec = 0;
        typename time_duration_type::fractional_seconds_type frac(0);

        typedef std::num_get<CharT, InItrT> num_get;
        if(!std::has_facet<num_get>(ios_arg.getloc())) {
          num_get* ng = new num_get();
          std::locale loc = std::locale(ios_arg.getloc(), ng);
          ios_arg.imbue(loc);
        }

        const_itr itr(m_time_duration_format.begin());
        while (itr != m_time_duration_format.end() && (sitr != stream_end)) {
          if (*itr == '%') {
            ++itr;
            if (*itr != '%') {
              switch(*itr) {
              case 'O':
                {


                  hour = var_string_to_int<hour_type, CharT>(sitr, stream_end,
                                      std::numeric_limits<hour_type>::digits10 + 1);
                  if(hour == -1){
                     return check_special_value(sitr, stream_end, td, c);
                  }
                  break;
                }
              case 'H':
                {
                  match_results mr;
                  hour = fixed_string_to_int<hour_type, CharT>(sitr, stream_end, mr, 2);
                  if(hour == -1){
                     return check_special_value(sitr, stream_end, td, c);
                  }
                  break;
                }
              case 'M':
                {
                  match_results mr;
                  min = fixed_string_to_int<min_type, CharT>(sitr, stream_end, mr, 2);
                  if(min == -1){
                     return check_special_value(sitr, stream_end, td, c);
                  }
                  break;
                }
              case 's':
              case 'S':
                {
                  match_results mr;
                  sec = fixed_string_to_int<sec_type, CharT>(sitr, stream_end, mr, 2);
                  if(sec == -1){
                     return check_special_value(sitr, stream_end, td, c);
                  }
                  if (*itr == 'S')
                    break;

                }
              case 'f':
                {

                  if(*sitr == '.') {
                    ++sitr;
                    parse_frac_type(sitr, stream_end, frac);


                    use_current_char = true;
                  }
                  else {
                    return check_special_value(sitr, stream_end, td, c);
                  }
                  break;
                }
              case 'F':
                {

                  if(*sitr == '.') {
                    ++sitr;
                    parse_frac_type(sitr, stream_end, frac);


                    use_current_char = true;
                  }
                  else {

                    use_current_char = true;
                  }
                  break;
                }
              default:
                {}
              }
            }
            else {
              ++sitr;
            }

            ++itr;
          }
          else {
            ++itr;


            if (use_current_char) {
              use_current_char = false;
            }
            else {
              ++sitr;
            }
          }
        }

        td = time_duration_type(hour, min, sec, frac);
        return sitr;
      }



      InItrT get(InItrT& sitr,
                 InItrT& stream_end,
                 std::ios_base& ios_arg,
                 time_type& t) const
      {
        string_type tz_str;
        return get(sitr, stream_end, ios_arg, t, tz_str, false);
      }

      InItrT get_local_time(InItrT& sitr,
                            InItrT& stream_end,
                            std::ios_base& ios_arg,
                            time_type& t,
                            string_type& tz_str) const
      {
        return get(sitr, stream_end, ios_arg, t, tz_str, true);
      }

    protected:

      InItrT get(InItrT& sitr,
                 InItrT& stream_end,
                 std::ios_base& ios_arg,
                 time_type& t,
                 string_type& tz_str,
                 bool time_is_local) const
      {

        while((sitr != stream_end) && std::isspace(*sitr)) { ++sitr; }

        bool use_current_char = false;
        bool use_current_format_char = false;


        char_type c = '\0';
        if((sitr != stream_end) && (*sitr == '-' || *sitr == '+')) {
          c = *sitr;
        }

        typedef typename time_duration_type::hour_type hour_type;
        typedef typename time_duration_type::min_type min_type;
        typedef typename time_duration_type::sec_type sec_type;


        hour_type hour = 0;
        min_type min = 0;
        sec_type sec = 0;
        typename time_duration_type::fractional_seconds_type frac(0);

        short day_of_year(0);




        year_type t_year(1400);
        month_type t_month(1);
        day_type t_day(1);

        typedef std::num_get<CharT, InItrT> num_get;
        if(!std::has_facet<num_get>(ios_arg.getloc())) {
          num_get* ng = new num_get();
          std::locale loc = std::locale(ios_arg.getloc(), ng);
          ios_arg.imbue(loc);
        }

        const_itr itr(this->m_format.begin());
        while (itr != this->m_format.end() && (sitr != stream_end)) {
          if (*itr == '%') {
            ++itr;
            if (*itr != '%') {

              switch(*itr) {

                case 'Y':
                case 'y':
                  {
                    char_type cs[3] = { '%', *itr };
                    string_type s(cs);
                    match_results mr;
                    try {
                      t_year = this->m_parser.parse_year(sitr, stream_end, s, mr);
                    }
                    catch(std::out_of_range&) {
                      if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                        t = time_type(static_cast<special_values>(mr.current_match));
                        return sitr;
                      }
                      else {
                        throw;
                      }
                    }
                    break;
                  }
                case 'B':
                case 'b':
                case 'm':
                  {
                    char_type cs[3] = { '%', *itr };
                    string_type s(cs);
                    match_results mr;
                    try {
                      t_month = this->m_parser.parse_month(sitr, stream_end, s, mr);
                    }
                    catch(std::out_of_range&) {
                      if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                        t = time_type(static_cast<special_values>(mr.current_match));
                        return sitr;
                      }
                      else {
                        throw;
                      }
                    }

                    if(mr.has_remaining()) {
                      use_current_char = true;
                    }
                    break;
                  }
                case 'a':
                case 'A':
                case 'w':
                  {

                    char_type cs[3] = { '%', *itr };
                    string_type s(cs);
                    match_results mr;
                    typename date_type::day_of_week_type wd(0);
                    try {
                      wd = this->m_parser.parse_weekday(sitr, stream_end, s, mr);
                    }
                    catch(std::out_of_range&) {
                      if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                        t = time_type(static_cast<special_values>(mr.current_match));
                        return sitr;
                      }
                      else {
                        throw;
                      }
                    }

                    if(mr.has_remaining()) {
                      use_current_char = true;
                    }
                    break;
                  }
                case 'j':
                  {

                    match_results mr;
                    day_of_year = fixed_string_to_int<unsigned short, CharT>(sitr, stream_end, mr, 3);
                    if(day_of_year == -1) {
                      if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                        t = time_type(static_cast<special_values>(mr.current_match));
                        return sitr;
                      }
                    }

                    typedef typename time_type::date_type::day_of_year_type day_of_year_type;
                    day_of_year_type t_day_of_year(day_of_year);
                    break;
                  }
                case 'd':
                  {
                    try {
                      t_day = this->m_parser.parse_day_of_month(sitr, stream_end);
                    }
                    catch(std::out_of_range&) {
                      match_results mr;
                      if(this->m_sv_parser.match(sitr, stream_end, mr)) {
                        t = time_type(static_cast<special_values>(mr.current_match));
                        return sitr;
                      }
                      else {
                        throw;
                      }
                    }
                    break;
                  }

                case 'H':
                  {
                    match_results mr;
                    hour = fixed_string_to_int<hour_type, CharT>(sitr, stream_end, mr, 2);
                    if(hour == -1){
                       return check_special_value(sitr, stream_end, t, c);
                    }
                    break;
                  }
                case 'M':
                  {
                    match_results mr;
                    min = fixed_string_to_int<min_type, CharT>(sitr, stream_end, mr, 2);
                    if(min == -1){
                       return check_special_value(sitr, stream_end, t, c);
                    }
                    break;
                  }
                case 's':
                case 'S':
                  {
                    match_results mr;
                    sec = fixed_string_to_int<sec_type, CharT>(sitr, stream_end, mr, 2);
                    if(sec == -1){
                       return check_special_value(sitr, stream_end, t, c);
                    }
                    if (*itr == 'S')
                      break;

                  }
                case 'f':
                  {

                    if(*sitr == '.') {
                      ++sitr;
                      parse_frac_type(sitr, stream_end, frac);


                      use_current_char = true;
                    }
                    else {
                      return check_special_value(sitr, stream_end, t, c);
                    }
                    break;
                  }
                case 'F':
                  {

                    if(*sitr == '.') {
                      ++sitr;
                      parse_frac_type(sitr, stream_end, frac);


                      use_current_char = true;
                    }
                    else {

                      use_current_char = true;
                    }
                    break;
                  }




                case 'Z':
                  {
                    if(time_is_local) {
                      ++itr;
                      if(*itr == 'P') {

                        while((sitr != stream_end) && std::isspace(*sitr)) { ++sitr; }

                        while((sitr != stream_end) && (!std::isspace(*sitr))) {
                          tz_str += *sitr;
                          ++sitr;
                        }
                      }
                      else {
                        use_current_format_char = true;
                      }

                    }
                    else {

                      use_current_char = true;
                    }

                    break;
                  }
                default:
                {}
              }
            }
            else {
              ++sitr;
            }

            if(use_current_format_char) {
              use_current_format_char = false;
            }
            else {
              ++itr;
            }

          }
          else {
            ++itr;


            if (use_current_char) {
              use_current_char = false;
            }
            else {
              ++sitr;
            }
          }
        }

        date_type d(not_a_date_time);
        if (day_of_year > 0) {
          d = date_type(static_cast<unsigned short>(t_year-1),12,31) + date_duration_type(day_of_year);
        }
        else {
          d = date_type(t_year, t_month, t_day);
        }

        time_duration_type td(hour, min, sec, frac);
        t = time_type(d, td);
        return sitr;
      }





      template<class temporal_type>
      inline
      InItrT check_special_value(InItrT& sitr,InItrT& stream_end, temporal_type& tt, char_type c='\0') const
      {
        match_results mr;
        if((c == '-' || c == '+') && (*sitr != c)) {
          mr.cache += c;
        }
        this->m_sv_parser.match(sitr, stream_end, mr);
        if(mr.current_match == match_results::PARSE_ERROR) {
          std::string tmp = convert_string_type<char_type, char>(mr.cache);
          boost::throw_exception(std::ios_base::failure("Parse failed. No match found for '" + tmp + "'"));
          std::abort();
        }
        tt = temporal_type(static_cast<special_values>(mr.current_match));
        return sitr;
      }


      void parse_frac_type(InItrT& sitr,
                           InItrT& stream_end,
                           fracional_seconds_type& frac) const
      {
        string_type cache;
        while((sitr != stream_end) && std::isdigit(*sitr)) {
          cache += *sitr;
          ++sitr;
        }
        if(cache.size() > 0) {
          unsigned short precision = time_duration_type::num_fractional_digits();

          if(cache.size() < precision) {
            frac = lexical_cast<fracional_seconds_type>(cache);
            frac = decimal_adjust(frac, static_cast<unsigned short>(precision - cache.size()));
          }
          else {

            frac = lexical_cast<fracional_seconds_type>(cache.substr(0, precision));
          }
        }
      }

    private:
      string_type m_time_duration_format;


      template<class int_type>
      inline
      int_type decimal_adjust(int_type val, const unsigned short places) const
      {
        unsigned long factor = 1;
        for(int i = 0; i < places; ++i){
          factor *= 10;
        }
        return val * factor;
      }

  };

template <class time_type, class CharT, class InItrT>
  std::locale::id time_input_facet<time_type, CharT, InItrT>::id;

template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::fractional_seconds_format = time_formats<CharT>::fractional_seconds_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::fractional_seconds_or_none_format = time_formats<CharT>::fractional_seconds_or_none_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::seconds_with_fractional_seconds_format = time_formats<CharT>::seconds_with_fractional_seconds_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::seconds_format = time_formats<CharT>::seconds_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::standard_format = time_formats<CharT>::standard_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::zone_abbrev_format = time_formats<CharT>::zone_abbrev_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::zone_name_format = time_formats<CharT>::zone_name_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::zone_iso_format = time_formats<CharT>::zone_iso_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::zone_iso_extended_format = time_formats<CharT>::zone_iso_extended_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::duration_seperator = time_formats<CharT>::duration_seperator;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::iso_time_format_specifier = time_formats<CharT>::iso_time_format_specifier;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::iso_time_format_extended_specifier = time_formats<CharT>::iso_time_format_extended_specifier;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::default_time_input_format = time_formats<CharT>::default_time_input_format;

  template <class time_type, class CharT, class InItrT>
  const typename time_input_facet<time_type, CharT, InItrT>::char_type*
  time_input_facet<time_type, CharT, InItrT>::default_time_duration_format = time_formats<CharT>::default_time_duration_format;


} }
# 17 "/usr/include/boost/date_time/posix_time/posix_time_io.hpp" 2 3 4






namespace boost {
namespace posix_time {
# 37 "/usr/include/boost/date_time/posix_time/posix_time_io.hpp" 3 4
  typedef boost::date_time::time_facet<ptime, wchar_t> wtime_facet;
  typedef boost::date_time::time_facet<ptime, char> time_facet;

  typedef boost::date_time::time_input_facet<ptime, wchar_t> wtime_input_facet;
  typedef boost::date_time::time_input_facet<ptime, char> time_input_facet;

  template <class CharT, class TraitsT>
  inline
  std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os,
             const ptime& p) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
    typedef std::time_put<CharT> std_ptime_facet;
    std::ostreambuf_iterator<CharT> oitr(os);
    if (std::has_facet<custom_ptime_facet>(os.getloc()))
      std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
    else {





      custom_ptime_facet* f = new custom_ptime_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(oitr, os, os.fill(), p);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, ptime& pt)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<time_input_facet>(is.getloc())) {
          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, pt);
        }
        else {
          time_input_facet* f = new time_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, pt);
        }
      }
      catch(...) {

        std::ios_base::iostate exception_mask = is.exceptions();


        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {

          is.setstate(std::ios_base::failbit);
        }
      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline
  std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os,
             const boost::posix_time::time_period& p) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
    typedef std::time_put<CharT> std_time_facet;
    std::ostreambuf_iterator<CharT> oitr(os);
    if (std::has_facet<custom_ptime_facet>(os.getloc())) {
      std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), p);
    }
    else {





      custom_ptime_facet* f = new custom_ptime_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(oitr, os, os.fill(), p);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, time_period& tp)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<time_input_facet>(is.getloc())) {
          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
        }
        else {
          time_input_facet* f = new time_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, tp);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }
      }
    }
    return is;
  }




  template <class CharT, class Traits>
  inline
  std::basic_ostream<CharT, Traits>&
  operator<<(std::basic_ostream<CharT, Traits>& os, const time_duration& td)
  {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::time_facet<ptime, CharT> custom_ptime_facet;
    typedef std::time_put<CharT> std_ptime_facet;
    std::ostreambuf_iterator<CharT> oitr(os);
    if (std::has_facet<custom_ptime_facet>(os.getloc()))
      std::use_facet<custom_ptime_facet>(os.getloc()).put(oitr, os, os.fill(), td);
    else {





      custom_ptime_facet* f = new custom_ptime_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(oitr, os, os.fill(), td);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, time_duration& td)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::time_input_facet<ptime, CharT> time_input_facet;
        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<time_input_facet>(is.getloc())) {
          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, td);
        }
        else {
          time_input_facet* f = new time_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, td);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }
      }
    }
    return is;
  }

} }
# 32 "/usr/include/boost/date_time/posix_time/posix_time.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/posix_time/time_parsers.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/posix_time/time_parsers.hpp" 3 4
namespace boost {

namespace posix_time {






  inline time_duration duration_from_string(const std::string& s) {
    return date_time::parse_delimited_time_duration<time_duration>(s);
  }

  inline ptime time_from_string(const std::string& s) {
    return date_time::parse_delimited_time<ptime>(s, ' ');
  }

  inline ptime from_iso_string(const std::string& s) {
    return date_time::parse_iso_time<ptime>(s, 'T');
  }



} }
# 35 "/usr/include/boost/date_time/posix_time/posix_time.hpp" 2 3 4
# 12 "/usr/include/boost/date_time/local_time/local_time.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 1 3 4
# 20 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 3 4
# 1 "/usr/include/boost/date_time/time_zone_base.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/time_zone_base.hpp" 3 4
namespace boost {
namespace date_time {
# 33 "/usr/include/boost/date_time/time_zone_base.hpp" 3 4
  template<typename time_type, typename CharT>
  class time_zone_base {
  public:
    typedef CharT char_type;
    typedef std::basic_string<CharT> string_type;
    typedef std::basic_ostringstream<CharT> stringstream_type;
    typedef typename time_type::date_type::year_type year_type;
    typedef typename time_type::time_duration_type time_duration_type;

    time_zone_base() {}
    virtual ~time_zone_base() {}

    virtual string_type dst_zone_abbrev() const=0;

    virtual string_type std_zone_abbrev() const=0;

    virtual string_type dst_zone_name() const=0;

    virtual string_type std_zone_name() const=0;

    virtual bool has_dst() const=0;

    virtual time_type dst_local_start_time(year_type y) const=0;

    virtual time_type dst_local_end_time(year_type y) const=0;

    virtual time_duration_type base_utc_offset() const=0;

    virtual time_duration_type dst_offset() const=0;

    virtual string_type to_posix_string() const =0;

  private:

  };






  template<class time_duration_type>
  class dst_adjustment_offsets
  {
  public:
    dst_adjustment_offsets(const time_duration_type& dst_adjust,
                           const time_duration_type& dst_start_offset,
                           const time_duration_type& dst_end_offset) :
      dst_adjust_(dst_adjust),
      dst_start_offset_(dst_start_offset),
      dst_end_offset_(dst_end_offset)
    {}


    time_duration_type dst_adjust_;

    time_duration_type dst_start_offset_;

    time_duration_type dst_end_offset_;
  };


} }
# 21 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 2 3 4



namespace boost {
namespace local_time {


  struct ambiguous_result : public std::logic_error
  {
    ambiguous_result (std::string const& msg = std::string()) :
      std::logic_error(std::string("Daylight Savings Results are ambiguous: " + msg)) {}
  };

  struct time_label_invalid : public std::logic_error
  {
    time_label_invalid (std::string const& msg = std::string()) :
      std::logic_error(std::string("Time label given is invalid: " + msg)) {}
  };
  struct dst_not_valid: public std::logic_error
  {
    dst_not_valid(std::string const& msg = std::string()) :
      std::logic_error(std::string("is_dst flag does not match resulting dst for time label given: " + msg)) {}
  };



  using date_time::time_is_dst_result;
  using date_time::is_in_dst;
  using date_time::is_not_in_dst;
  using date_time::ambiguous;
  using date_time::invalid_time_label;
# 62 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 3 4
  template<class utc_time_=posix_time::ptime,
           class tz_type=date_time::time_zone_base<utc_time_,char> >
  class local_date_time_base : public date_time::base_time<utc_time_,
                                                            boost::posix_time::posix_time_system> {
  public:
    typedef utc_time_ utc_time_type;
    typedef typename utc_time_type::time_duration_type time_duration_type;
    typedef typename utc_time_type::date_type date_type;
    typedef typename date_type::duration_type date_duration_type;
    typedef typename utc_time_type::time_system_type time_system_type;
# 81 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 3 4
    local_date_time_base(utc_time_type t,
                         boost::shared_ptr<tz_type> tz) :
      date_time::base_time<utc_time_type, time_system_type>(t),
      zone_(tz)
    {

    }
# 100 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 3 4
    local_date_time_base(date_type d,
                         time_duration_type td,
                         boost::shared_ptr<tz_type> tz,
                         bool dst_flag) :
      date_time::base_time<utc_time_type,time_system_type>(construction_adjustment(utc_time_type(d, td), tz, dst_flag)),
      zone_(tz)
    {
      if(tz != boost::shared_ptr<tz_type>() && tz->has_dst()){


        time_is_dst_result result = check_dst(d, td, tz);
        bool in_dst = (result == is_in_dst);


        if(result == invalid_time_label){

          std::ostringstream ss;
          ss << "time given: " << d << ' ' << td;
          boost::throw_exception(time_label_invalid(ss.str()));
        }
        else if(result != ambiguous && in_dst != dst_flag){


          std::ostringstream ss;
          ss.setf(std::ios_base::boolalpha);
          ss << "flag given: dst=" << dst_flag << ", dst calculated: dst=" << in_dst;
          boost::throw_exception(dst_not_valid(ss.str()));
        }


      }
    }


    enum DST_CALC_OPTIONS { EXCEPTION_ON_ERROR, NOT_DATE_TIME_ON_ERROR };






    local_date_time_base(date_type d,
                         time_duration_type td,
                         boost::shared_ptr<tz_type> tz,
                         DST_CALC_OPTIONS calc_option) :

      date_time::base_time<utc_time_type,time_system_type>(utc_time_type(d,td)),
      zone_(tz)
    {
      time_is_dst_result result = check_dst(d, td, tz);
      if(result == ambiguous) {
        if(calc_option == EXCEPTION_ON_ERROR){
          std::ostringstream ss;
          ss << "time given: " << d << ' ' << td;
          boost::throw_exception(ambiguous_result(ss.str()));
        }
        else{
          this->time_ = posix_time::posix_time_system::get_time_rep(date_type(date_time::not_a_date_time), time_duration_type(date_time::not_a_date_time));
        }
      }
      else if(result == invalid_time_label){
        if(calc_option == EXCEPTION_ON_ERROR){
          std::ostringstream ss;
          ss << "time given: " << d << ' ' << td;
          boost::throw_exception(time_label_invalid(ss.str()));
        }
        else{
          this->time_ = posix_time::posix_time_system::get_time_rep(date_type(date_time::not_a_date_time), time_duration_type(date_time::not_a_date_time));
        }
      }
      else if(result == is_in_dst){
        utc_time_type t =
          construction_adjustment(utc_time_type(d, td), tz, true);
        this->time_ = posix_time::posix_time_system::get_time_rep(t.date(),
                                                            t.time_of_day());
      }
      else{
        utc_time_type t =
          construction_adjustment(utc_time_type(d, td), tz, false);
        this->time_ = posix_time::posix_time_system::get_time_rep(t.date(),
                                                            t.time_of_day());
      }
    }







    static time_is_dst_result check_dst(date_type d,
                                        time_duration_type td,
                                        boost::shared_ptr<tz_type> tz)
    {
      if(tz != boost::shared_ptr<tz_type>() && tz->has_dst()) {
        typedef typename date_time::dst_calculator<date_type, time_duration_type> dst_calculator;
        return dst_calculator::local_is_dst(
            d, td,
            tz->dst_local_start_time(d.year()).date(),
            tz->dst_local_start_time(d.year()).time_of_day(),
            tz->dst_local_end_time(d.year()).date(),
            tz->dst_local_end_time(d.year()).time_of_day(),
            tz->dst_offset()
        );
      }
      else{
        return is_not_in_dst;
      }
    }


    ~local_date_time_base() {}


    local_date_time_base(const local_date_time_base& rhs) :
      date_time::base_time<utc_time_type, time_system_type>(rhs),
      zone_(rhs.zone_)
    {}


    explicit local_date_time_base(const boost::date_time::special_values sv,
                                  boost::shared_ptr<tz_type> tz = boost::shared_ptr<tz_type>()) :
      date_time::base_time<utc_time_type, time_system_type>(utc_time_type(sv)),
      zone_(tz)
    {}


    boost::shared_ptr<tz_type> zone() const
    {
      return zone_;
    }

    bool is_dst() const
    {
      if(zone_ != boost::shared_ptr<tz_type>() && zone_->has_dst() && !this->is_special()) {

        utc_time_type lt(this->time_);
        lt += zone_->base_utc_offset();



        switch(check_dst(lt.date(), lt.time_of_day(), zone_)){
          case is_not_in_dst:
            return false;
          case is_in_dst:
            return true;
          case ambiguous:
            if(lt + zone_->dst_offset() < zone_->dst_local_end_time(lt.date().year())) {
              return true;
            }
            break;
          case invalid_time_label:
            if(lt >= zone_->dst_local_start_time(lt.date().year())) {
              return true;
            }
            break;
        }
      }
      return false;
    }

    utc_time_type utc_time() const
    {
      return utc_time_type(this->time_);
    }

    utc_time_type local_time() const
    {
      if(zone_ != boost::shared_ptr<tz_type>()){
        utc_time_type lt = this->utc_time() + zone_->base_utc_offset();
        if (is_dst()) {
          lt += zone_->dst_offset();
        }
        return lt;
      }
      return utc_time_type(this->time_);
    }




    std::string to_string() const
    {

      std::ostringstream ss;
      if(this->is_special()){
        ss << utc_time();
        return ss.str();
      }
      if(zone_ == boost::shared_ptr<tz_type>()) {
        ss << utc_time() << " UTC";
        return ss.str();
      }
      bool is_dst_ = is_dst();
      utc_time_type lt = this->utc_time() + zone_->base_utc_offset();
      if (is_dst_) {
        lt += zone_->dst_offset();
      }
      ss << local_time() << " ";
      if (is_dst()) {
        ss << zone_->dst_zone_abbrev();
      }
      else {
        ss << zone_->std_zone_abbrev();
      }
      return ss.str();
    }


    local_date_time_base local_time_in(boost::shared_ptr<tz_type> new_tz,
                                       time_duration_type td=time_duration_type(0,0,0)) const
    {
      return local_date_time_base(utc_time_type(this->time_) + td, new_tz);
    }





    std::string zone_name(bool as_offset=false) const
    {
      if(zone_ == boost::shared_ptr<tz_type>()) {
        if(as_offset) {
          return std::string("Z");
        }
        else {
          return std::string("Coordinated Universal Time");
        }
      }
      if (is_dst()) {
        if(as_offset) {
          time_duration_type td = zone_->base_utc_offset();
          td += zone_->dst_offset();
          return zone_as_offset(td, ":");
        }
        else {
          return zone_->dst_zone_name();
        }
      }
      else {
        if(as_offset) {
          time_duration_type td = zone_->base_utc_offset();
          return zone_as_offset(td, ":");
        }
        else {
          return zone_->std_zone_name();
        }
      }
    }




    std::string zone_abbrev(bool as_offset=false) const
    {
      if(zone_ == boost::shared_ptr<tz_type>()) {
        if(as_offset) {
          return std::string("Z");
        }
        else {
          return std::string("UTC");
        }
      }
      if (is_dst()) {
        if(as_offset) {
          time_duration_type td = zone_->base_utc_offset();
          td += zone_->dst_offset();
          return zone_as_offset(td, "");
        }
        else {
          return zone_->dst_zone_abbrev();
        }
      }
      else {
        if(as_offset) {
          time_duration_type td = zone_->base_utc_offset();
          return zone_as_offset(td, "");
        }
        else {
          return zone_->std_zone_abbrev();
        }
      }
    }


    std::string zone_as_posix_string() const
    {
      if(zone_ == shared_ptr<tz_type>()) {
        return std::string("UTC+00");
      }
      return zone_->to_posix_string();
    }
# 400 "/usr/include/boost/date_time/local_time/local_date_time.hpp" 3 4
    bool operator==(const local_date_time_base& rhs) const
    {
      return time_system_type::is_equal(this->time_, rhs.time_);
    }

    bool operator!=(const local_date_time_base& rhs) const
    {
      return !(*this == rhs);
    }

    bool operator<(const local_date_time_base& rhs) const
    {
      return time_system_type::is_less(this->time_, rhs.time_);
    }

    bool operator<=(const local_date_time_base& rhs) const
    {
      return (*this < rhs || *this == rhs);
    }

    bool operator>(const local_date_time_base& rhs) const
    {
      return !(*this <= rhs);
    }

    bool operator>=(const local_date_time_base& rhs) const
    {
      return (*this > rhs || *this == rhs);
    }


    local_date_time_base operator+(const date_duration_type& dd) const
    {
      return local_date_time_base(time_system_type::add_days(this->time_,dd), zone_);
    }

    local_date_time_base operator+=(const date_duration_type& dd)
    {
      this->time_ = time_system_type::add_days(this->time_,dd);
      return *this;
    }

    local_date_time_base operator-(const date_duration_type& dd) const
    {
      return local_date_time_base(time_system_type::subtract_days(this->time_,dd), zone_);
    }

    local_date_time_base operator-=(const date_duration_type& dd)
    {
      this->time_ = time_system_type::subtract_days(this->time_,dd);
      return *this;
    }

    local_date_time_base operator+(const time_duration_type& td) const
    {
      return local_date_time_base(time_system_type::add_time_duration(this->time_,td), zone_);
    }

    local_date_time_base operator+=(const time_duration_type& td)
    {
      this->time_ = time_system_type::add_time_duration(this->time_,td);
      return *this;
    }

    local_date_time_base operator-(const time_duration_type& td) const
    {
      return local_date_time_base(time_system_type::subtract_time_duration(this->time_,td), zone_);
    }

    local_date_time_base operator-=(const time_duration_type& td)
    {
      this->time_ = time_system_type::subtract_time_duration(this->time_,td);
      return *this;
    }

    time_duration_type operator-(const local_date_time_base& rhs) const
    {
      return utc_time_type(this->time_) - utc_time_type(rhs.time_);
    }
  private:
    boost::shared_ptr<tz_type> zone_;




    utc_time_type construction_adjustment(utc_time_type t,
                                          boost::shared_ptr<tz_type> z,
                                          bool dst_flag)
    {
      if(z != boost::shared_ptr<tz_type>()) {
        if(dst_flag && z->has_dst()) {
          t -= z->dst_offset();
        }
        t -= z->base_utc_offset();
      }
      return t;
    }



    std::string zone_as_offset(const time_duration_type& td,
                               const std::string& separator) const
    {
      std::ostringstream ss;
      if(td.is_negative()) {



        ss << "-";
      }
      else {
        ss << "+";
      }
      ss << std::setw(2) << std::setfill('0')
          << date_time::absolute_value(td.hours())
          << separator
          << std::setw(2) << std::setfill('0')
          << date_time::absolute_value(td.minutes());
      return ss.str();
    }
  };


  typedef local_date_time_base<> local_date_time;

} }
# 13 "/usr/include/boost/date_time/local_time/local_time.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/local_time/local_time_types.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/local_time/local_time_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/local_time/date_duration_operators.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/local_time/date_duration_operators.hpp" 3 4
namespace boost {
namespace local_time {
# 29 "/usr/include/boost/date_time/local_time/date_duration_operators.hpp" 3 4
  inline
  local_date_time
  operator+(const local_date_time& t, const boost::gregorian::months& m)
  {
    return t + m.get_offset(t.utc_time().date());
  }




  inline
  local_date_time
  operator+=(local_date_time& t, const boost::gregorian::months& m)
  {
    return t += m.get_offset(t.utc_time().date());
  }




  inline
  local_date_time
  operator-(const local_date_time& t, const boost::gregorian::months& m)
  {

    return t + m.get_neg_offset(t.utc_time().date());
  }




  inline
  local_date_time
  operator-=(local_date_time& t, const boost::gregorian::months& m)
  {

    return t += m.get_neg_offset(t.utc_time().date());
  }






  inline
  local_date_time
  operator+(const local_date_time& t, const boost::gregorian::years& y)
  {
    return t + y.get_offset(t.utc_time().date());
  }




  inline
  local_date_time
  operator+=(local_date_time& t, const boost::gregorian::years& y)
  {
    return t += y.get_offset(t.utc_time().date());
  }




  inline
  local_date_time
  operator-(const local_date_time& t, const boost::gregorian::years& y)
  {

    return t + y.get_neg_offset(t.utc_time().date());
  }




  inline
  local_date_time
  operator-=(local_date_time& t, const boost::gregorian::years& y)
  {

    return t += y.get_neg_offset(t.utc_time().date());
  }


}}
# 17 "/usr/include/boost/date_time/local_time/local_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/local_time/custom_time_zone.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/local_time/custom_time_zone.hpp" 3 4
# 1 "/usr/include/boost/date_time/time_zone_names.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/time_zone_names.hpp" 3 4
namespace boost {
namespace date_time {

  template<class CharT>
  struct default_zone_names {
    public:
      typedef CharT char_type;
      static const char_type standard_name[9];
      static const char_type standard_abbrev[11];
      static const char_type non_dst_identifier[7];
  };
  template <class CharT>
  const typename default_zone_names<CharT>::char_type
  default_zone_names<CharT>::standard_name[9] =
    {'s','t','d','_','n','a','m','e'};

  template <class CharT>
  const typename default_zone_names<CharT>::char_type
  default_zone_names<CharT>::standard_abbrev[11] =
    {'s','t','d','_','a','b','b','r','e','v'};

  template <class CharT>
  const typename default_zone_names<CharT>::char_type
  default_zone_names<CharT>::non_dst_identifier[7] =
    {'n','o','-','d','s','t'};
# 48 "/usr/include/boost/date_time/time_zone_names.hpp" 3 4
  template<class CharT>
  class time_zone_names_base
  {
  public:
    typedef std::basic_string<CharT> string_type;
    time_zone_names_base() :
      std_zone_name_(default_zone_names<CharT>::standard_name),
      std_zone_abbrev_(default_zone_names<CharT>::standard_abbrev),
      dst_zone_name_(default_zone_names<CharT>::non_dst_identifier),
      dst_zone_abbrev_(default_zone_names<CharT>::non_dst_identifier)
    {}
    time_zone_names_base(const string_type& std_zone_name_str,
                         const string_type& std_zone_abbrev_str,
                         const string_type& dst_zone_name_str,
                         const string_type& dst_zone_abbrev_str) :
      std_zone_name_(std_zone_name_str),
      std_zone_abbrev_(std_zone_abbrev_str),
      dst_zone_name_(dst_zone_name_str),
      dst_zone_abbrev_(dst_zone_abbrev_str)
    {}
    string_type dst_zone_abbrev() const
    {
      return dst_zone_abbrev_;
    }
    string_type std_zone_abbrev() const
    {
      return std_zone_abbrev_;
    }
    string_type dst_zone_name() const
    {
      return dst_zone_name_;
    }
    string_type std_zone_name() const
    {
      return std_zone_name_;
    }
  private:
    string_type std_zone_name_;
    string_type std_zone_abbrev_;
    string_type dst_zone_name_;
    string_type dst_zone_abbrev_;

  };




} }
# 13 "/usr/include/boost/date_time/local_time/custom_time_zone.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/local_time/dst_transition_day_rules.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/local_time/dst_transition_day_rules.hpp" 3 4
# 1 "/usr/include/boost/date_time/dst_transition_generators.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/dst_transition_generators.hpp" 3 4
namespace boost {
namespace date_time {


    template<class date_type>
    class dst_day_calc_rule
    {
    public:
      typedef typename date_type::year_type year_type;
      virtual ~dst_day_calc_rule() {}
      virtual date_type start_day(year_type y) const=0;
      virtual std::string start_rule_as_string() const=0;
      virtual date_type end_day(year_type y) const=0;
      virtual std::string end_rule_as_string() const=0;

    };
# 36 "/usr/include/boost/date_time/dst_transition_generators.hpp" 3 4
    template<class spec>
    class day_calc_dst_rule : public dst_day_calc_rule<typename spec::date_type>
    {
    public:
      typedef typename spec::date_type date_type;
      typedef typename date_type::year_type year_type;
      typedef typename spec::start_rule start_rule;
      typedef typename spec::end_rule end_rule;
      day_calc_dst_rule(start_rule dst_start,
                        end_rule dst_end) :
        dst_start_(dst_start),
        dst_end_(dst_end)
      {}
      virtual date_type start_day(year_type y) const
      {
        return dst_start_.get_date(y);
      }
      virtual std::string start_rule_as_string() const
      {
        return dst_start_.to_string();
      }
      virtual date_type end_day(year_type y) const
      {
        return dst_end_.get_date(y);
      }
      virtual std::string end_rule_as_string() const
      {
        return dst_end_.to_string();
      }
    private:
      start_rule dst_start_;
      end_rule dst_end_;
    };


} }
# 14 "/usr/include/boost/date_time/local_time/dst_transition_day_rules.hpp" 2 3 4

namespace boost {
namespace local_time {


    typedef date_time::dst_day_calc_rule<gregorian::date> dst_calc_rule;

    struct partial_date_rule_spec
    {
      typedef gregorian::date date_type;
      typedef gregorian::partial_date start_rule;
      typedef gregorian::partial_date end_rule;
    };


    typedef date_time::day_calc_dst_rule<partial_date_rule_spec> partial_date_dst_rule;

    struct first_last_rule_spec
    {
      typedef gregorian::date date_type;
      typedef gregorian::first_kday_of_month start_rule;
      typedef gregorian::last_kday_of_month end_rule;
    };


    typedef date_time::day_calc_dst_rule<first_last_rule_spec> first_last_dst_rule;

    struct last_last_rule_spec
    {
      typedef gregorian::date date_type;
      typedef gregorian::last_kday_of_month start_rule;
      typedef gregorian::last_kday_of_month end_rule;
    };


    typedef date_time::day_calc_dst_rule<last_last_rule_spec> last_last_dst_rule;

    struct nth_last_rule_spec
    {
      typedef gregorian::date date_type;
      typedef gregorian::nth_kday_of_month start_rule;
      typedef gregorian::last_kday_of_month end_rule;
    };


    typedef date_time::day_calc_dst_rule<nth_last_rule_spec> nth_last_dst_rule;

    struct nth_kday_rule_spec
    {
      typedef gregorian::date date_type;
      typedef gregorian::nth_kday_of_month start_rule;
      typedef gregorian::nth_kday_of_month end_rule;
    };


    typedef date_time::day_calc_dst_rule<nth_kday_rule_spec> nth_kday_dst_rule;

    typedef date_time::day_calc_dst_rule<nth_kday_rule_spec> nth_day_of_the_week_in_month_dst_rule;


} }
# 15 "/usr/include/boost/date_time/local_time/custom_time_zone.hpp" 2 3 4




namespace boost {
namespace local_time {


  typedef boost::date_time::dst_adjustment_offsets<boost::posix_time::time_duration> dst_adjustment_offsets;

  typedef boost::shared_ptr<dst_calc_rule> dst_calc_rule_ptr;


  template<class CharT>
  class custom_time_zone_base : public date_time::time_zone_base<posix_time::ptime,CharT> {
  public:
    typedef boost::posix_time::time_duration time_duration_type;
    typedef date_time::time_zone_base<posix_time::ptime,CharT> base_type;
    typedef typename base_type::string_type string_type;
    typedef typename base_type::stringstream_type stringstream_type;
    typedef date_time::time_zone_names_base<CharT> time_zone_names;
    typedef CharT char_type;

    custom_time_zone_base(const time_zone_names& zone_names,
                     const time_duration_type& utc_offset,
                     const dst_adjustment_offsets& dst_shift,
                     boost::shared_ptr<dst_calc_rule> calc_rule) :
      zone_names_(zone_names),
      base_utc_offset_(utc_offset),
      dst_offsets_(dst_shift),
      dst_calc_rules_(calc_rule)
    {}
    virtual ~custom_time_zone_base() {}
    virtual string_type dst_zone_abbrev() const
    {
      return zone_names_.dst_zone_abbrev();
    }
    virtual string_type std_zone_abbrev() const
    {
      return zone_names_.std_zone_abbrev();
    }
    virtual string_type dst_zone_name() const
    {
      return zone_names_.dst_zone_name();
    }
    virtual string_type std_zone_name() const
    {
      return zone_names_.std_zone_name();
    }

    virtual bool has_dst() const
    {
      return (dst_calc_rules_);
    }

    virtual posix_time::ptime dst_local_start_time(gregorian::greg_year y) const
    {
      gregorian::date d(gregorian::not_a_date_time);
      if (dst_calc_rules_) {
        d = dst_calc_rules_->start_day(y);
      }
      return posix_time::ptime(d, dst_offsets_.dst_start_offset_);
    }

    virtual posix_time::ptime dst_local_end_time(gregorian::greg_year y) const
    {
      gregorian::date d(gregorian::not_a_date_time);
      if (dst_calc_rules_) {
        d = dst_calc_rules_->end_day(y);
      }
      return posix_time::ptime(d, dst_offsets_.dst_end_offset_);
    }

    virtual time_duration_type base_utc_offset() const
    {
      return base_utc_offset_;
    }

    virtual time_duration_type dst_offset() const
    {
      return dst_offsets_.dst_adjust_;
    }

    virtual string_type to_posix_string() const
    {

      stringstream_type ss;
      ss.fill('0');
      boost::shared_ptr<dst_calc_rule> no_rules;

      ss << std_zone_abbrev();

      if(base_utc_offset().is_negative()) {

        ss << '-' << std::setw(2) << base_utc_offset().invert_sign().hours();
      }
      else {
        ss << '+' << std::setw(2) << base_utc_offset().hours();
      }
      if(base_utc_offset().minutes() != 0 || base_utc_offset().seconds() != 0) {
        ss << ':' << std::setw(2) << base_utc_offset().minutes();
        if(base_utc_offset().seconds() != 0) {
          ss << ':' << std::setw(2) << base_utc_offset().seconds();
        }
      }
      if(dst_calc_rules_ != no_rules) {

        ss << dst_zone_abbrev();

        if(dst_offset().is_negative()) {

          ss << '-' << std::setw(2) << dst_offset().invert_sign().hours();
        }
        else {
          ss << '+' << std::setw(2) << dst_offset().hours();
        }
        if(dst_offset().minutes() != 0 || dst_offset().seconds() != 0) {
          ss << ':' << std::setw(2) << dst_offset().minutes();
          if(dst_offset().seconds() != 0) {
            ss << ':' << std::setw(2) << dst_offset().seconds();
          }
        }

        ss << ',' << date_time::convert_string_type<char, char_type>(dst_calc_rules_->start_rule_as_string()) << '/'
           << std::setw(2) << dst_offsets_.dst_start_offset_.hours() << ':'
           << std::setw(2) << dst_offsets_.dst_start_offset_.minutes();
        if(dst_offsets_.dst_start_offset_.seconds() != 0) {
          ss << ':' << std::setw(2) << dst_offsets_.dst_start_offset_.seconds();
        }

        ss << ',' << date_time::convert_string_type<char, char_type>(dst_calc_rules_->end_rule_as_string()) << '/'
           << std::setw(2) << dst_offsets_.dst_end_offset_.hours() << ':'
           << std::setw(2) << dst_offsets_.dst_end_offset_.minutes();
        if(dst_offsets_.dst_end_offset_.seconds() != 0) {
          ss << ':' << std::setw(2) << dst_offsets_.dst_end_offset_.seconds();
        }
      }

      return ss.str();
    }
  private:
    time_zone_names zone_names_;
    bool has_dst_;
    time_duration_type base_utc_offset_;
    dst_adjustment_offsets dst_offsets_;
    boost::shared_ptr<dst_calc_rule> dst_calc_rules_;
  };

  typedef custom_time_zone_base<char> custom_time_zone;

} }
# 19 "/usr/include/boost/date_time/local_time/local_time_types.hpp" 2 3 4

namespace boost {
namespace local_time {

  typedef boost::date_time::period<local_date_time,
                                   boost::posix_time::time_duration> local_time_period;

  typedef date_time::time_itr<local_date_time> local_time_iterator;

  typedef date_time::second_clock<local_date_time> local_sec_clock;
  typedef date_time::microsec_clock<local_date_time> local_microsec_clock;

  typedef date_time::time_zone_base<posix_time::ptime, char> time_zone;
  typedef date_time::time_zone_base<posix_time::ptime, wchar_t> wtime_zone;


  typedef boost::shared_ptr<time_zone> time_zone_ptr;
  typedef boost::shared_ptr<wtime_zone> wtime_zone_ptr;

  typedef date_time::time_zone_names_base<char> time_zone_names;
  typedef date_time::time_zone_names_base<wchar_t> wtime_zone_names;


  using date_time::special_values;
  using date_time::not_special;
  using date_time::neg_infin;
  using date_time::pos_infin;
  using date_time::not_a_date_time;
  using date_time::max_date_time;
  using date_time::min_date_time;

}}
# 14 "/usr/include/boost/date_time/local_time/local_time.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/local_time/local_time_io.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/local_time/local_time_io.hpp" 3 4
# 1 "/usr/include/boost/date_time/local_time/posix_time_zone.hpp" 1 3 4
# 24 "/usr/include/boost/date_time/local_time/posix_time_zone.hpp" 3 4
namespace boost{
namespace local_time{


  struct bad_offset : public std::out_of_range
  {
    bad_offset(std::string const& msg = std::string()) :
      std::out_of_range(std::string("Offset out of range: " + msg)) {}
  };

  struct bad_adjustment : public std::out_of_range
  {
    bad_adjustment(std::string const& msg = std::string()) :
      std::out_of_range(std::string("Adjustment out of range: " + msg)) {}
  };

  typedef boost::date_time::dst_adjustment_offsets<boost::posix_time::time_duration> dst_adjustment_offsets;
# 69 "/usr/include/boost/date_time/local_time/posix_time_zone.hpp" 3 4
  template<class CharT>
  class posix_time_zone_base : public date_time::time_zone_base<posix_time::ptime,CharT> {
  public:
    typedef boost::posix_time::time_duration time_duration_type;
    typedef date_time::time_zone_names_base<CharT> time_zone_names;
    typedef date_time::time_zone_base<posix_time::ptime,CharT> base_type;
    typedef typename base_type::string_type string_type;
    typedef CharT char_type;
    typedef typename base_type::stringstream_type stringstream_type;
    typedef boost::char_separator<char_type, std::char_traits<char_type> > char_separator_type;
    typedef boost::tokenizer<char_separator_type,
                             typename string_type::const_iterator,
                             string_type> tokenizer_type;
    typedef typename tokenizer_type::iterator tokenizer_iterator_type;


    posix_time_zone_base(const string_type& s) :

      zone_names_(),
      has_dst_(false),
      base_utc_offset_(posix_time::hours(0)),
      dst_offsets_(posix_time::hours(0),posix_time::hours(0),posix_time::hours(0)),
      dst_calc_rules_()
    {





      const char_type sep_chars[2] = {','};

      char_separator_type sep(sep_chars);
      tokenizer_type tokens(s, sep);
      tokenizer_iterator_type it = tokens.begin(), end = tokens.end();
      if (it == end)
        ::boost::exception_detail::throw_exception_(std::invalid_argument("Could not parse time zone name"),__PRETTY_FUNCTION__,"/usr/include/boost/date_time/local_time/posix_time_zone.hpp",104);
      calc_zone(*it++);
      if(has_dst_)
      {
        if (it == end)
          ::boost::exception_detail::throw_exception_(std::invalid_argument("Could not parse DST begin time"),__PRETTY_FUNCTION__,"/usr/include/boost/date_time/local_time/posix_time_zone.hpp",109);
        string_type dst_begin = *it++;

        if (it == end)
          ::boost::exception_detail::throw_exception_(std::invalid_argument("Could not parse DST end time"),__PRETTY_FUNCTION__,"/usr/include/boost/date_time/local_time/posix_time_zone.hpp",113);
        string_type dst_end = *it;
        calc_rules(dst_begin, dst_end);
      }
    }
    virtual ~posix_time_zone_base() {}

    virtual string_type std_zone_abbrev()const
    {
      return zone_names_.std_zone_abbrev();
    }


    virtual string_type dst_zone_abbrev() const
    {
      return zone_names_.dst_zone_abbrev();
    }



    virtual string_type std_zone_name()const
    {
      return zone_names_.std_zone_name();
    }




    virtual string_type dst_zone_name()const
    {
      return zone_names_.dst_zone_name();
    }

    virtual bool has_dst()const
    {
      return has_dst_;
    }

    virtual posix_time::ptime dst_local_start_time(gregorian::greg_year y)const
    {
      gregorian::date d(gregorian::not_a_date_time);
      if(has_dst_)
      {
        d = dst_calc_rules_->start_day(y);
      }
      return posix_time::ptime(d, dst_offsets_.dst_start_offset_);
    }

    virtual posix_time::ptime dst_local_end_time(gregorian::greg_year y)const
    {
      gregorian::date d(gregorian::not_a_date_time);
      if(has_dst_)
      {
        d = dst_calc_rules_->end_day(y);
      }
      return posix_time::ptime(d, dst_offsets_.dst_end_offset_);
    }

    virtual time_duration_type base_utc_offset()const
    {
      return base_utc_offset_;
    }

    virtual time_duration_type dst_offset()const
    {
      return dst_offsets_.dst_adjust_;
    }


    virtual string_type to_posix_string() const
    {

      stringstream_type ss;
      ss.fill('0');
      boost::shared_ptr<dst_calc_rule> no_rules;

      ss << std_zone_abbrev();

      if(base_utc_offset().is_negative()) {

        ss << '-' << std::setw(2) << base_utc_offset().invert_sign().hours();
      }
      else {
        ss << '+' << std::setw(2) << base_utc_offset().hours();
      }
      if(base_utc_offset().minutes() != 0 || base_utc_offset().seconds() != 0) {
        ss << ':' << std::setw(2) << base_utc_offset().minutes();
        if(base_utc_offset().seconds() != 0) {
          ss << ':' << std::setw(2) << base_utc_offset().seconds();
        }
      }
      if(dst_calc_rules_ != no_rules) {

        ss << dst_zone_abbrev();

        if(dst_offset().is_negative()) {

          ss << '-' << std::setw(2) << dst_offset().invert_sign().hours();
        }
        else {
          ss << '+' << std::setw(2) << dst_offset().hours();
        }
        if(dst_offset().minutes() != 0 || dst_offset().seconds() != 0) {
          ss << ':' << std::setw(2) << dst_offset().minutes();
          if(dst_offset().seconds() != 0) {
            ss << ':' << std::setw(2) << dst_offset().seconds();
          }
        }

        ss << ',' << date_time::convert_string_type<char, char_type>(dst_calc_rules_->start_rule_as_string()) << '/'
           << std::setw(2) << dst_offsets_.dst_start_offset_.hours() << ':'
           << std::setw(2) << dst_offsets_.dst_start_offset_.minutes();
        if(dst_offsets_.dst_start_offset_.seconds() != 0) {
          ss << ':' << std::setw(2) << dst_offsets_.dst_start_offset_.seconds();
        }

        ss << ',' << date_time::convert_string_type<char, char_type>(dst_calc_rules_->end_rule_as_string()) << '/'
           << std::setw(2) << dst_offsets_.dst_end_offset_.hours() << ':'
           << std::setw(2) << dst_offsets_.dst_end_offset_.minutes();
        if(dst_offsets_.dst_end_offset_.seconds() != 0) {
          ss << ':' << std::setw(2) << dst_offsets_.dst_end_offset_.seconds();
        }
      }

      return ss.str();
    }
  private:
    time_zone_names zone_names_;
    bool has_dst_;
    time_duration_type base_utc_offset_;
    dst_adjustment_offsets dst_offsets_;
    boost::shared_ptr<dst_calc_rule> dst_calc_rules_;





    void calc_zone(const string_type& obj){
      const char_type empty_string[2] = {'\0'};
      stringstream_type ss(empty_string);
      typename string_type::const_pointer sit = obj.c_str(), obj_end = sit + obj.size();
      string_type l_std_zone_abbrev, l_dst_zone_abbrev;


      while(std::isalpha(*sit)){
        ss << *sit++;
      }
      l_std_zone_abbrev = ss.str();
      ss.str(empty_string);


      if(sit != obj_end){

        while(sit != obj_end && !std::isalpha(*sit)){
          ss << *sit++;
        }
        base_utc_offset_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(ss.str());
        ss.str(empty_string);


        if(base_utc_offset_ < time_duration_type(-12,0,0) ||
          base_utc_offset_ > time_duration_type(14,0,0))
        {
          boost::throw_exception(bad_offset(posix_time::to_simple_string(base_utc_offset_)));
        }
      }


      if(sit != obj_end){
        has_dst_ = true;


        while(sit != obj_end && std::isalpha(*sit)){
          ss << *sit++;
        }
        l_dst_zone_abbrev = ss.str();
        ss.str(empty_string);


        if(sit != obj_end){

          while(sit != obj_end && !std::isalpha(*sit)){
            ss << *sit++;
          }
          dst_offsets_.dst_adjust_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(ss.str());
          ss.str(empty_string);
        }
        else{
          dst_offsets_.dst_adjust_ = posix_time::hours(1);
        }


        if(dst_offsets_.dst_adjust_ <= time_duration_type(-24,0,0) ||
            dst_offsets_.dst_adjust_ >= time_duration_type(24,0,0))
        {
          boost::throw_exception(bad_adjustment(posix_time::to_simple_string(dst_offsets_.dst_adjust_)));
        }
      }

      zone_names_ = time_zone_names(l_std_zone_abbrev, l_std_zone_abbrev, l_dst_zone_abbrev, l_dst_zone_abbrev);
    }

    void calc_rules(const string_type& start, const string_type& end){





      const char_type sep_chars[2] = {'/'};

      char_separator_type sep(sep_chars);
      tokenizer_type st_tok(start, sep);
      tokenizer_type et_tok(end, sep);
      tokenizer_iterator_type sit = st_tok.begin();
      tokenizer_iterator_type eit = et_tok.begin();


      char_type x = string_type(*sit).at(0);
      if(x == 'M'){
        M_func(*sit, *eit);
      }
      else if(x == 'J'){
        julian_no_leap(*sit, *eit);
      }
      else{
        julian_day(*sit, *eit);
      }

      ++sit;
      ++eit;


      if(sit != st_tok.end()){
        dst_offsets_.dst_start_offset_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(*sit);
      }
      else{

        dst_offsets_.dst_start_offset_ = posix_time::hours(2);
      }

      if(dst_offsets_.dst_start_offset_ < time_duration_type(0,0,0) ||
          dst_offsets_.dst_start_offset_ >= time_duration_type(24,0,0))
      {
        boost::throw_exception(bad_offset(posix_time::to_simple_string(dst_offsets_.dst_start_offset_)));
      }


      if(eit != et_tok.end()){
        dst_offsets_.dst_end_offset_ = date_time::str_from_delimited_time_duration<time_duration_type,char_type>(*eit);
      }
      else{

        dst_offsets_.dst_end_offset_ = posix_time::hours(2);
      }

      if(dst_offsets_.dst_end_offset_ < time_duration_type(0,0,0) ||
        dst_offsets_.dst_end_offset_ >= time_duration_type(24,0,0))
      {
        boost::throw_exception(bad_offset(posix_time::to_simple_string(dst_offsets_.dst_end_offset_)));
      }
    }





    void M_func(const string_type& s, const string_type& e){
      typedef gregorian::nth_kday_of_month nkday;
      unsigned short sm=0,sw=0,sd=0,em=0,ew=0,ed=0;





      const char_type sep_chars[3] = {'M','.'};

      char_separator_type sep(sep_chars);
      tokenizer_type stok(s, sep), etok(e, sep);

      tokenizer_iterator_type it = stok.begin();
      sm = lexical_cast<unsigned short>(*it++);
      sw = lexical_cast<unsigned short>(*it++);
      sd = lexical_cast<unsigned short>(*it);

      it = etok.begin();
      em = lexical_cast<unsigned short>(*it++);
      ew = lexical_cast<unsigned short>(*it++);
      ed = lexical_cast<unsigned short>(*it);

      dst_calc_rules_ = shared_ptr<dst_calc_rule>(
        new nth_kday_dst_rule(
          nth_last_dst_rule::start_rule(
            static_cast<nkday::week_num>(sw),sd,sm),
          nth_last_dst_rule::start_rule(
            static_cast<nkday::week_num>(ew),ed,em)
          )
      );
    }



    void julian_no_leap(const string_type& s, const string_type& e){
      typedef gregorian::gregorian_calendar calendar;
      const unsigned short year = 2001;
      unsigned short sm=1;
      int sd=0;
      sd = lexical_cast<int>(s.substr(1));
      while(sd >= calendar::end_of_month_day(year,sm)){
        sd -= calendar::end_of_month_day(year,sm++);
      }
      unsigned short em=1;
      int ed=0;
      ed = lexical_cast<int>(e.substr(1));
      while(ed > calendar::end_of_month_day(year,em)){
        ed -= calendar::end_of_month_day(year,em++);
      }

      dst_calc_rules_ = shared_ptr<dst_calc_rule>(
        new partial_date_dst_rule(
          partial_date_dst_rule::start_rule(
            sd, static_cast<date_time::months_of_year>(sm)),
          partial_date_dst_rule::end_rule(
            ed, static_cast<date_time::months_of_year>(em))
          )
      );
    }



    void julian_day(const string_type& s, const string_type& e){
      int sd=0, ed=0;
      sd = lexical_cast<int>(s);
      ed = lexical_cast<int>(e);
      dst_calc_rules_ = shared_ptr<dst_calc_rule>(
        new partial_date_dst_rule(
          partial_date_dst_rule::start_rule(++sd),
          partial_date_dst_rule::end_rule(++ed)
          )
      );
    }


    static std::string td_as_string(const time_duration_type& td)
    {
      std::string s;



      std::stringstream ss;
      ss << td;
      s = ss.str();

      return s;
    }
  };

  typedef posix_time_zone_base<char> posix_time_zone;

} }
# 19 "/usr/include/boost/date_time/local_time/local_time_io.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/local_time/conversion.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/local_time/conversion.hpp" 3 4
namespace boost {
namespace local_time {


inline
std::tm to_tm(const local_date_time& lt) {
  std::tm lt_tm = posix_time::to_tm(lt.local_time());
  if(lt.is_dst()){
    lt_tm.tm_isdst = 1;
  }
  else{
    lt_tm.tm_isdst = 0;
  }
  return lt_tm;
}


}}
# 20 "/usr/include/boost/date_time/local_time/local_time_io.hpp" 2 3 4

namespace boost {
namespace local_time {

  typedef boost::date_time::time_facet<local_date_time, wchar_t> wlocal_time_facet;
  typedef boost::date_time::time_facet<local_date_time, char> local_time_facet;

  typedef boost::date_time::time_input_facet<local_date_time::utc_time_type,wchar_t> wlocal_time_input_facet;
  typedef boost::date_time::time_input_facet<local_date_time::utc_time_type,char> local_time_input_facet;


  template<class CharT, class TraitsT>
  inline
  std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os, const local_date_time& ldt)
  {
    boost::io::ios_flags_saver iflags(os);
    typedef local_date_time time_type;
    typedef date_time::time_facet<time_type, CharT> custom_time_facet;
    typedef std::time_put<CharT> std_time_facet;
    std::ostreambuf_iterator<CharT> oitr(os);

    if(std::has_facet<custom_time_facet>(os.getloc())) {
      std::use_facet<custom_time_facet>(os.getloc()).put(oitr,
                                                         os,
                                                         os.fill(),
                                                         ldt);
    }
    else {
      custom_time_facet* f = new custom_time_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(oitr, os, os.fill(), ldt);
    }

    return os;
  }



  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, local_date_time& ldt)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename local_date_time::utc_time_type utc_time_type;
        typedef typename date_time::time_input_facet<utc_time_type, CharT> time_input_facet;


        std::basic_string<CharT> tz_str;
        utc_time_type pt(not_a_date_time);

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<time_input_facet>(is.getloc())) {
          std::use_facet<time_input_facet>(is.getloc()).get_local_time(sit, str_end, is, pt, tz_str);
        }
        else {
          time_input_facet* f = new time_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get_local_time(sit, str_end, is, pt, tz_str);
        }
        if(tz_str.empty()) {
          time_zone_ptr null_ptr;

          ldt = local_date_time(pt, null_ptr);
        }
        else {
          time_zone_ptr tz_ptr(new posix_time_zone(date_time::convert_string_type<CharT,char>(tz_str)));


          ldt = local_date_time(pt.date(), pt.time_of_day(), tz_ptr, local_date_time::EXCEPTION_ON_ERROR);
        }
      }
      catch(...) {

        std::ios_base::iostate exception_mask = is.exceptions();


        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {

          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }


  template <class CharT, class TraitsT>
  inline
  std::basic_ostream<CharT, TraitsT>&
  operator<<(std::basic_ostream<CharT, TraitsT>& os,
             const boost::local_time::local_time_period& p) {
    boost::io::ios_flags_saver iflags(os);
    typedef boost::date_time::time_facet<local_date_time, CharT> custom_facet;
    typedef std::time_put<CharT> std_time_facet;
    std::ostreambuf_iterator<CharT> oitr(os);
    if (std::has_facet<custom_facet>(os.getloc())) {
      std::use_facet<custom_facet>(os.getloc()).put(oitr, os, os.fill(), p);
    }
    else {





      custom_facet* f = new custom_facet();
      std::locale l = std::locale(os.getloc(), f);
      os.imbue(l);
      f->put(oitr, os, os.fill(), p);
    }
    return os;
  }


  template <class CharT, class Traits>
  inline
  std::basic_istream<CharT, Traits>&
  operator>>(std::basic_istream<CharT, Traits>& is, boost::local_time::local_time_period& tp)
  {
    boost::io::ios_flags_saver iflags(is);
    typename std::basic_istream<CharT, Traits>::sentry strm_sentry(is, false);
    if (strm_sentry) {
      try {
        typedef typename date_time::time_input_facet<local_date_time, CharT> time_input_facet;

        std::istreambuf_iterator<CharT,Traits> sit(is), str_end;
        if(std::has_facet<time_input_facet>(is.getloc())) {
          std::use_facet<time_input_facet>(is.getloc()).get(sit, str_end, is, tp);
        }
        else {
          time_input_facet* f = new time_input_facet();
          std::locale l = std::locale(is.getloc(), f);
          is.imbue(l);
          f->get(sit, str_end, is, tp);
        }
      }
      catch(...) {
        std::ios_base::iostate exception_mask = is.exceptions();
        if(std::ios_base::failbit & exception_mask) {
          try { is.setstate(std::ios_base::failbit); }
          catch(std::ios_base::failure&) {}
          throw;
        }
        else {
          is.setstate(std::ios_base::failbit);
        }

      }
    }
    return is;
  }

} }
# 16 "/usr/include/boost/date_time/local_time/local_time.hpp" 2 3 4



# 1 "/usr/include/boost/date_time/local_time/tz_database.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/local_time/tz_database.hpp" 3 4
# 1 "/usr/include/boost/date_time/tz_db_base.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/tz_db_base.hpp" 3 4
# 1 "/usr/include/c++/4.8/fstream" 1 3 4
# 36 "/usr/include/c++/4.8/fstream" 3 4
       
# 37 "/usr/include/c++/4.8/fstream" 3




# 1 "/usr/include/c++/4.8/cstdio" 1 3
# 39 "/usr/include/c++/4.8/cstdio" 3
       
# 40 "/usr/include/c++/4.8/cstdio" 3
# 42 "/usr/include/c++/4.8/fstream" 2 3
# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/basic_file.h" 1 3
# 37 "/usr/include/i386-linux-gnu/c++/4.8/bits/basic_file.h" 3
       
# 38 "/usr/include/i386-linux-gnu/c++/4.8/bits/basic_file.h" 3


# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++io.h" 1 3
# 35 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++io.h" 3
# 1 "/usr/include/c++/4.8/cstdio" 1 3
# 39 "/usr/include/c++/4.8/cstdio" 3
       
# 40 "/usr/include/c++/4.8/cstdio" 3
# 36 "/usr/include/i386-linux-gnu/c++/4.8/bits/c++io.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{


  typedef __gthread_mutex_t __c_lock;


  typedef FILE __c_file;


}
# 41 "/usr/include/i386-linux-gnu/c++/4.8/bits/basic_file.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _CharT>
    class __basic_file;


  template<>
    class __basic_file<char>
    {

      __c_file* _M_cfile;


      bool _M_cfile_created;

    public:
      __basic_file(__c_lock* __lock = 0) throw ();

      __basic_file*
      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);

      __basic_file*
      sys_open(__c_file* __file, ios_base::openmode);

      __basic_file*
      sys_open(int __fd, ios_base::openmode __mode) throw ();

      __basic_file*
      close();

      __attribute__ ((__pure__)) bool
      is_open() const throw ();

      __attribute__ ((__pure__)) int
      fd() throw ();

      __attribute__ ((__pure__)) __c_file*
      file() throw ();

      ~__basic_file();

      streamsize
      xsputn(const char* __s, streamsize __n);

      streamsize
      xsputn_2(const char* __s1, streamsize __n1,
        const char* __s2, streamsize __n2);

      streamsize
      xsgetn(char* __s, streamsize __n);

      streamoff
      seekoff(streamoff __off, ios_base::seekdir __way) throw ();

      int
      sync();

      streamsize
      showmanyc();
    };


}
# 43 "/usr/include/c++/4.8/fstream" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{

# 71 "/usr/include/c++/4.8/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
    {
    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;
      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef __basic_file<char> __file_type;
      typedef typename traits_type::state_type __state_type;
      typedef codecvt<char_type, char, __state_type> __codecvt_type;

      friend class ios_base;

    protected:


      __c_lock _M_lock;


      __file_type _M_file;


      ios_base::openmode _M_mode;


      __state_type _M_state_beg;




      __state_type _M_state_cur;



      __state_type _M_state_last;


      char_type* _M_buf;






      size_t _M_buf_size;


      bool _M_buf_allocated;
# 133 "/usr/include/c++/4.8/fstream" 3
      bool _M_reading;
      bool _M_writing;







      char_type _M_pback;
      char_type* _M_pback_cur_save;
      char_type* _M_pback_end_save;
      bool _M_pback_init;



      const __codecvt_type* _M_codecvt;






      char* _M_ext_buf;




      streamsize _M_ext_buf_size;






      const char* _M_ext_next;
      char* _M_ext_end;






      void
      _M_create_pback()
      {
 if (!_M_pback_init)
   {
     _M_pback_cur_save = this->gptr();
     _M_pback_end_save = this->egptr();
     this->setg(&_M_pback, &_M_pback, &_M_pback + 1);
     _M_pback_init = true;
   }
      }






      void
      _M_destroy_pback() throw()
      {
 if (_M_pback_init)
   {

     _M_pback_cur_save += this->gptr() != this->eback();
     this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save);
     _M_pback_init = false;
   }
      }

    public:







      basic_filebuf();




      virtual
      ~basic_filebuf()
      { this->close(); }





      bool
      is_open() const throw()
      { return _M_file.is_open(); }
# 269 "/usr/include/c++/4.8/fstream" 3
      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);
# 296 "/usr/include/c++/4.8/fstream" 3
      __filebuf_type*
      close();

    protected:
      void
      _M_allocate_internal_buffer();

      void
      _M_destroy_internal_buffer() throw();


      virtual streamsize
      showmanyc();






      virtual int_type
      underflow();

      virtual int_type
      pbackfail(int_type __c = _Traits::eof());
# 328 "/usr/include/c++/4.8/fstream" 3
      virtual int_type
      overflow(int_type __c = _Traits::eof());



      bool
      _M_convert_to_external(char_type*, streamsize);
# 348 "/usr/include/c++/4.8/fstream" 3
      virtual __streambuf_type*
      setbuf(char_type* __s, streamsize __n);

      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 __pos,
       ios_base::openmode __mode = ios_base::in | ios_base::out);


      pos_type
      _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);

      int
      _M_get_ext_pos(__state_type &__state);

      virtual int
      sync();

      virtual void
      imbue(const locale& __loc);

      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);

      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);


      bool
      _M_terminate_output();
# 394 "/usr/include/c++/4.8/fstream" 3
      void
      _M_set_buffer(streamsize __off)
      {
  const bool __testin = _M_mode & ios_base::in;
  const bool __testout = _M_mode & ios_base::out;

 if (__testin && __off > 0)
   this->setg(_M_buf, _M_buf, _M_buf + __off);
 else
   this->setg(_M_buf, _M_buf, _M_buf);

 if (__testout && __off == 0 && _M_buf_size > 1 )
   this->setp(_M_buf, _M_buf + _M_buf_size - 1);
 else
   this->setp(0, 0);
      }
    };
# 426 "/usr/include/c++/4.8/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_ifstream : public basic_istream<_CharT, _Traits>
    {
    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_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 453 "/usr/include/c++/4.8/fstream" 3
      basic_ifstream() : __istream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 466 "/usr/include/c++/4.8/fstream" 3
      explicit
      basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 498 "/usr/include/c++/4.8/fstream" 3
      ~basic_ifstream()
      { }
# 508 "/usr/include/c++/4.8/fstream" 3
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      bool
      is_open()
      { return _M_filebuf.is_open(); }



      bool
      is_open() const
      { return _M_filebuf.is_open(); }
# 537 "/usr/include/c++/4.8/fstream" 3
      void
      open(const char* __s, ios_base::openmode __mode = ios_base::in)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::in))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 575 "/usr/include/c++/4.8/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
# 598 "/usr/include/c++/4.8/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_ofstream : public basic_ostream<_CharT,_Traits>
    {
    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_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 625 "/usr/include/c++/4.8/fstream" 3
      basic_ofstream(): __ostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 639 "/usr/include/c++/4.8/fstream" 3
      explicit
      basic_ofstream(const char* __s,
       ios_base::openmode __mode = ios_base::out|ios_base::trunc)
      : __ostream_type(), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 673 "/usr/include/c++/4.8/fstream" 3
      ~basic_ofstream()
      { }
# 683 "/usr/include/c++/4.8/fstream" 3
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      bool
      is_open()
      { return _M_filebuf.is_open(); }



      bool
      is_open() const
      { return _M_filebuf.is_open(); }
# 712 "/usr/include/c++/4.8/fstream" 3
      void
      open(const char* __s,
    ios_base::openmode __mode = ios_base::out | ios_base::trunc)
      {
 if (!_M_filebuf.open(__s, __mode | ios_base::out))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 752 "/usr/include/c++/4.8/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
# 775 "/usr/include/c++/4.8/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_fstream : public basic_iostream<_CharT, _Traits>
    {
    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_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ios<char_type, traits_type> __ios_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 803 "/usr/include/c++/4.8/fstream" 3
      basic_fstream()
      : __iostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 815 "/usr/include/c++/4.8/fstream" 3
      explicit
      basic_fstream(const char* __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __iostream_type(0), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }
# 846 "/usr/include/c++/4.8/fstream" 3
      ~basic_fstream()
      { }
# 856 "/usr/include/c++/4.8/fstream" 3
      __filebuf_type*
      rdbuf() const
      { return const_cast<__filebuf_type*>(&_M_filebuf); }





      bool
      is_open()
      { return _M_filebuf.is_open(); }



      bool
      is_open() const
      { return _M_filebuf.is_open(); }
# 885 "/usr/include/c++/4.8/fstream" 3
      void
      open(const char* __s,
    ios_base::openmode __mode = ios_base::in | ios_base::out)
      {
 if (!_M_filebuf.open(__s, __mode))
   this->setstate(ios_base::failbit);
 else


   this->clear();
      }
# 925 "/usr/include/c++/4.8/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };


}

# 1 "/usr/include/c++/4.8/bits/fstream.tcc" 1 3
# 37 "/usr/include/c++/4.8/bits/fstream.tcc" 3
       
# 38 "/usr/include/c++/4.8/bits/fstream.tcc" 3



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_allocate_internal_buffer()
    {


      if (!_M_buf_allocated && !_M_buf)
 {
   _M_buf = new char_type[_M_buf_size];
   _M_buf_allocated = true;
 }
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_destroy_internal_buffer() throw()
    {
      if (_M_buf_allocated)
 {
   delete [] _M_buf;
   _M_buf = 0;
   _M_buf_allocated = false;
 }
      delete [] _M_ext_buf;
      _M_ext_buf = 0;
      _M_ext_buf_size = 0;
      _M_ext_next = 0;
      _M_ext_end = 0;
    }

  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>::
    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
    _M_state_last(), _M_buf(0), _M_buf_size(8192),
    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
    _M_ext_end(0)
    {
      if (has_facet<__codecvt_type>(this->_M_buf_locale))
 _M_codecvt = &use_facet<__codecvt_type>(this->_M_buf_locale);
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    open(const char* __s, ios_base::openmode __mode)
    {
      __filebuf_type *__ret = 0;
      if (!this->is_open())
 {
   _M_file.open(__s, __mode);
   if (this->is_open())
     {
       _M_allocate_internal_buffer();
       _M_mode = __mode;


       _M_reading = false;
       _M_writing = false;
       _M_set_buffer(-1);


       _M_state_last = _M_state_cur = _M_state_beg;


       if ((__mode & ios_base::ate)
    && this->seekoff(0, ios_base::end, __mode)
    == pos_type(off_type(-1)))
  this->close();
       else
  __ret = this;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    close()
    {
      if (!this->is_open())
 return 0;

      bool __testfail = false;
      {

 struct __close_sentry
 {
   basic_filebuf *__fb;
   __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
   ~__close_sentry ()
   {
     __fb->_M_mode = ios_base::openmode(0);
     __fb->_M_pback_init = false;
     __fb->_M_destroy_internal_buffer();
     __fb->_M_reading = false;
     __fb->_M_writing = false;
     __fb->_M_set_buffer(-1);
     __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
   }
 } __cs (this);

 try
   {
     if (!_M_terminate_output())
       __testfail = true;
   }
 catch(__cxxabiv1::__forced_unwind&)
   {
     _M_file.close();
     throw;
   }
 catch(...)
   { __testfail = true; }
      }

      if (!_M_file.close())
 __testfail = true;

      if (__testfail)
 return 0;
      else
 return this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    showmanyc()
    {
      streamsize __ret = -1;
      const bool __testin = _M_mode & ios_base::in;
      if (__testin && this->is_open())
 {


   __ret = this->egptr() - this->gptr();







   if (__check_facet(_M_codecvt).encoding() >= 0)

     __ret += _M_file.showmanyc() / _M_codecvt->max_length();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = _M_mode & ios_base::in;
      if (__testin)
 {
   if (_M_writing)
     {
       if (overflow() == traits_type::eof())
  return __ret;
       _M_set_buffer(-1);
       _M_writing = false;
     }



   _M_destroy_pback();

   if (this->gptr() < this->egptr())
     return traits_type::to_int_type(*this->gptr());


   const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;


   bool __got_eof = false;

   streamsize __ilen = 0;
   codecvt_base::result __r = codecvt_base::ok;
   if (__check_facet(_M_codecvt).always_noconv())
     {
       __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
          __buflen);
       if (__ilen == 0)
  __got_eof = true;
     }
   else
     {


       const int __enc = _M_codecvt->encoding();
       streamsize __blen;
       streamsize __rlen;
       if (__enc > 0)
  __blen = __rlen = __buflen * __enc;
       else
  {
    __blen = __buflen + _M_codecvt->max_length() - 1;
    __rlen = __buflen;
  }
       const streamsize __remainder = _M_ext_end - _M_ext_next;
       __rlen = __rlen > __remainder ? __rlen - __remainder : 0;



       if (_M_reading && this->egptr() == this->eback() && __remainder)
  __rlen = 0;



       if (_M_ext_buf_size < __blen)
  {
    char* __buf = new char[__blen];
    if (__remainder)
      __builtin_memcpy(__buf, _M_ext_next, __remainder);

    delete [] _M_ext_buf;
    _M_ext_buf = __buf;
    _M_ext_buf_size = __blen;
  }
       else if (__remainder)
  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);

       _M_ext_next = _M_ext_buf;
       _M_ext_end = _M_ext_buf + __remainder;
       _M_state_last = _M_state_cur;

       do
  {
    if (__rlen > 0)
      {



        if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
   {
     __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid")

                          );
   }
        streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
        if (__elen == 0)
   __got_eof = true;
        else if (__elen == -1)
   break;
        _M_ext_end += __elen;
      }

    char_type* __iend = this->eback();
    if (_M_ext_next < _M_ext_end)
      __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
      _M_ext_end, _M_ext_next,
      this->eback(),
      this->eback() + __buflen, __iend);
    if (__r == codecvt_base::noconv)
      {
        size_t __avail = _M_ext_end - _M_ext_buf;
        __ilen = std::min(__avail, __buflen);
        traits_type::copy(this->eback(),
     reinterpret_cast<char_type*>
     (_M_ext_buf), __ilen);
        _M_ext_next = _M_ext_buf + __ilen;
      }
    else
      __ilen = __iend - this->eback();




    if (__r == codecvt_base::error)
      break;

    __rlen = 1;
  }
       while (__ilen == 0 && !__got_eof);
     }

   if (__ilen > 0)
     {
       _M_set_buffer(__ilen);
       _M_reading = true;
       __ret = traits_type::to_int_type(*this->gptr());
     }
   else if (__got_eof)
     {



       _M_set_buffer(-1);
       _M_reading = false;


       if (__r == codecvt_base::partial)
  __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file")
                                       );
     }
   else if (__r == codecvt_base::error)
     __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file")
                                    );
   else
     __throw_ios_failure(("basic_filebuf::underflow " "error reading the file")
                             );
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    pbackfail(int_type __i)
    {
      int_type __ret = traits_type::eof();
      const bool __testin = _M_mode & ios_base::in;
      if (__testin)
 {
   if (_M_writing)
     {
       if (overflow() == traits_type::eof())
  return __ret;
       _M_set_buffer(-1);
       _M_writing = false;
     }


   const bool __testpb = _M_pback_init;
   const bool __testeof = traits_type::eq_int_type(__i, __ret);
   int_type __tmp;
   if (this->eback() < this->gptr())
     {
       this->gbump(-1);
       __tmp = traits_type::to_int_type(*this->gptr());
     }
   else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
     {
       __tmp = this->underflow();
       if (traits_type::eq_int_type(__tmp, __ret))
  return __ret;
     }
   else
     {





       return __ret;
     }



   if (!__testeof && traits_type::eq_int_type(__i, __tmp))
     __ret = __i;
   else if (__testeof)
     __ret = traits_type::not_eof(__i);
   else if (!__testpb)
     {
       _M_create_pback();
       _M_reading = true;
       *this->gptr() = traits_type::to_char_type(__i);
       __ret = __i;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    overflow(int_type __c)
    {
      int_type __ret = traits_type::eof();
      const bool __testeof = traits_type::eq_int_type(__c, __ret);
      const bool __testout = _M_mode & ios_base::out;
      if (__testout)
 {
          if (_M_reading)
            {
              _M_destroy_pback();
              const int __gptr_off = _M_get_ext_pos(_M_state_last);
              if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
                  == pos_type(off_type(-1)))
                return __ret;
            }
   if (this->pbase() < this->pptr())
     {

       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }



       if (_M_convert_to_external(this->pbase(),
      this->pptr() - this->pbase()))
  {
    _M_set_buffer(0);
    __ret = traits_type::not_eof(__c);
  }
     }
   else if (_M_buf_size > 1)
     {



       _M_set_buffer(0);
       _M_writing = true;
       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }
       __ret = traits_type::not_eof(__c);
     }
   else
     {

       char_type __conv = traits_type::to_char_type(__c);
       if (__testeof || _M_convert_to_external(&__conv, 1))
  {
    _M_writing = true;
    __ret = traits_type::not_eof(__c);
  }
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
    {

      streamsize __elen;
      streamsize __plen;
      if (__check_facet(_M_codecvt).always_noconv())
 {
   __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
   __plen = __ilen;
 }
      else
 {


   streamsize __blen = __ilen * _M_codecvt->max_length();
   char* __buf = static_cast<char*>(__builtin_alloca(__blen));

   char* __bend;
   const char_type* __iend;
   codecvt_base::result __r;
   __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
    __iend, __buf, __buf + __blen, __bend);

   if (__r == codecvt_base::ok || __r == codecvt_base::partial)
     __blen = __bend - __buf;
   else if (__r == codecvt_base::noconv)
     {

       __buf = reinterpret_cast<char*>(__ibuf);
       __blen = __ilen;
     }
   else
     __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
                           );

   __elen = _M_file.xsputn(__buf, __blen);
   __plen = __blen;


   if (__r == codecvt_base::partial && __elen == __plen)
     {
       const char_type* __iresume = __iend;
       streamsize __rlen = this->pptr() - __iend;
       __r = _M_codecvt->out(_M_state_cur, __iresume,
        __iresume + __rlen, __iend, __buf,
        __buf + __blen, __bend);
       if (__r != codecvt_base::error)
  {
    __rlen = __bend - __buf;
    __elen = _M_file.xsputn(__buf, __rlen);
    __plen = __rlen;
  }
       else
  __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error")
                        );
     }
 }
      return __elen == __plen;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    xsgetn(_CharT* __s, streamsize __n)
    {

      streamsize __ret = 0;
      if (_M_pback_init)
 {
   if (__n > 0 && this->gptr() == this->eback())
     {
       *__s++ = *this->gptr();
       this->gbump(1);
       __ret = 1;
       --__n;
     }
   _M_destroy_pback();
 }
      else if (_M_writing)
 {
    if (overflow() == traits_type::eof())
      return __ret;
    _M_set_buffer(-1);
    _M_writing = false;
  }




      const bool __testin = _M_mode & ios_base::in;
      const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;

      if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
     && __testin)
   {

     const streamsize __avail = this->egptr() - this->gptr();
     if (__avail != 0)
       {
        traits_type::copy(__s, this->gptr(), __avail);
         __s += __avail;
        this->setg(this->eback(), this->gptr() + __avail,
     this->egptr());
        __ret += __avail;
        __n -= __avail;
       }



     streamsize __len;
     for (;;)
       {
         __len = _M_file.xsgetn(reinterpret_cast<char*>(__s),
           __n);
         if (__len == -1)
    __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file")
                                );
         if (__len == 0)
    break;

         __n -= __len;
         __ret += __len;
         if (__n == 0)
    break;

         __s += __len;
       }

     if (__n == 0)
       {
         _M_set_buffer(0);
         _M_reading = true;
       }
     else if (__len == 0)
       {



         _M_set_buffer(-1);
         _M_reading = false;
       }
   }
      else
   __ret += __streambuf_type::xsgetn(__s, __n);

      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    xsputn(const _CharT* __s, streamsize __n)
    {
      streamsize __ret = 0;



      const bool __testout = _M_mode & ios_base::out;
      if (__check_facet(_M_codecvt).always_noconv()
     && __testout && !_M_reading)
 {

   const streamsize __chunk = 1ul << 10;
   streamsize __bufavail = this->epptr() - this->pptr();


   if (!_M_writing && _M_buf_size > 1)
     __bufavail = _M_buf_size - 1;

   const streamsize __limit = std::min(__chunk, __bufavail);
   if (__n >= __limit)
     {
       const streamsize __buffill = this->pptr() - this->pbase();
       const char* __buf = reinterpret_cast<const char*>(this->pbase());
       __ret = _M_file.xsputn_2(__buf, __buffill,
           reinterpret_cast<const char*>(__s),
           __n);
       if (__ret == __buffill + __n)
  {
    _M_set_buffer(0);
    _M_writing = true;
  }
       if (__ret > __buffill)
  __ret -= __buffill;
       else
  __ret = 0;
     }
   else
     __ret = __streambuf_type::xsputn(__s, __n);
 }
       else
  __ret = __streambuf_type::xsputn(__s, __n);
       return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
    basic_filebuf<_CharT, _Traits>::
    setbuf(char_type* __s, streamsize __n)
    {
      if (!this->is_open())
 {
   if (__s == 0 && __n == 0)
     _M_buf_size = 1;
   else if (__s && __n > 0)
     {
# 700 "/usr/include/c++/4.8/bits/fstream.tcc" 3
       _M_buf = __s;
       _M_buf_size = __n;
     }
 }
      return this;
    }




  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
    {
      int __width = 0;
      if (_M_codecvt)
 __width = _M_codecvt->encoding();
      if (__width < 0)
 __width = 0;

      pos_type __ret = pos_type(off_type(-1));
      const bool __testfail = __off != 0 && __width <= 0;
      if (this->is_open() && !__testfail)
 {




   bool __no_movement = __way == ios_base::cur && __off == 0
     && (!_M_writing || _M_codecvt->always_noconv());


   if (!__no_movement)
     _M_destroy_pback();






   __state_type __state = _M_state_beg;
   off_type __computed_off = __off * __width;
   if (_M_reading && __way == ios_base::cur)
     {
       __state = _M_state_last;
       __computed_off += _M_get_ext_pos(__state);
     }
   if (!__no_movement)
     __ret = _M_seek(__computed_off, __way, __state);
   else
     {
       if (_M_writing)
  __computed_off = this->pptr() - this->pbase();

        off_type __file_off = _M_file.seekoff(0, ios_base::cur);
        if (__file_off != off_type(-1))
  {
    __ret = __file_off + __computed_off;
    __ret.state(__state);
  }
     }
 }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekpos(pos_type __pos, ios_base::openmode)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (this->is_open())
 {

   _M_destroy_pback();
   __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (_M_terminate_output())
 {
   off_type __file_off = _M_file.seekoff(__off, __way);
   if (__file_off != off_type(-1))
     {
       _M_reading = false;
       _M_writing = false;
       _M_ext_next = _M_ext_end = _M_ext_buf;
       _M_set_buffer(-1);
       _M_state_cur = __state;
       __ret = __file_off;
       __ret.state(_M_state_cur);
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    int basic_filebuf<_CharT, _Traits>::
    _M_get_ext_pos(__state_type& __state)
    {
      if (_M_codecvt->always_noconv())
        return this->gptr() - this->egptr();
      else
        {



          const int __gptr_off =
            _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
                               this->gptr() - this->eback());
          return _M_ext_buf + __gptr_off - _M_ext_end;
        }
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_terminate_output()
    {

      bool __testvalid = true;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __testvalid = false;
 }


      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
   && __testvalid)
 {



   const size_t __blen = 128;
   char __buf[__blen];
   codecvt_base::result __r;
   streamsize __ilen = 0;

   do
     {
       char* __next;
       __r = _M_codecvt->unshift(_M_state_cur, __buf,
     __buf + __blen, __next);
       if (__r == codecvt_base::error)
  __testvalid = false;
       else if (__r == codecvt_base::ok ||
         __r == codecvt_base::partial)
  {
    __ilen = __next - __buf;
    if (__ilen > 0)
      {
        const streamsize __elen = _M_file.xsputn(__buf, __ilen);
        if (__elen != __ilen)
   __testvalid = false;
      }
  }
     }
   while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);

   if (__testvalid)
     {




       const int_type __tmp = this->overflow();
       if (traits_type::eq_int_type(__tmp, traits_type::eof()))
  __testvalid = false;
     }
 }
      return __testvalid;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_filebuf<_CharT, _Traits>::
    sync()
    {


      int __ret = 0;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __ret = -1;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    imbue(const locale& __loc)
    {
      bool __testvalid = true;

      const __codecvt_type* _M_codecvt_tmp = 0;
      if (__builtin_expect(has_facet<__codecvt_type>(__loc), true))
 _M_codecvt_tmp = &use_facet<__codecvt_type>(__loc);

      if (this->is_open())
 {

   if ((_M_reading || _M_writing)
       && __check_facet(_M_codecvt).encoding() == -1)
     __testvalid = false;
   else
     {
       if (_M_reading)
  {
    if (__check_facet(_M_codecvt).always_noconv())
      {
        if (_M_codecvt_tmp
     && !__check_facet(_M_codecvt_tmp).always_noconv())
   __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
                 != pos_type(off_type(-1));
      }
    else
      {

        _M_ext_next = _M_ext_buf
   + _M_codecvt->length(_M_state_last, _M_ext_buf,
          _M_ext_next,
          this->gptr() - this->eback());
        const streamsize __remainder = _M_ext_end - _M_ext_next;
        if (__remainder)
   __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);

        _M_ext_next = _M_ext_buf;
        _M_ext_end = _M_ext_buf + __remainder;
        _M_set_buffer(-1);
        _M_state_last = _M_state_cur = _M_state_beg;
      }
  }
       else if (_M_writing && (__testvalid = _M_terminate_output()))
  _M_set_buffer(-1);
     }
 }

      if (__testvalid)
 _M_codecvt = _M_codecvt_tmp;
      else
 _M_codecvt = 0;
    }




  extern template class basic_filebuf<char>;
  extern template class basic_ifstream<char>;
  extern template class basic_ofstream<char>;
  extern template class basic_fstream<char>;


  extern template class basic_filebuf<wchar_t>;
  extern template class basic_ifstream<wchar_t>;
  extern template class basic_ofstream<wchar_t>;
  extern template class basic_fstream<wchar_t>;




}
# 937 "/usr/include/c++/4.8/fstream" 2 3
# 16 "/usr/include/boost/date_time/tz_db_base.hpp" 2 3 4
# 25 "/usr/include/boost/date_time/tz_db_base.hpp" 3 4
namespace boost {
  namespace date_time {


    class data_not_accessible : public std::logic_error
    {
     public:
       data_not_accessible() :
         std::logic_error(std::string("Unable to locate or access the required datafile."))
       {}
       data_not_accessible(const std::string& filespec) :
         std::logic_error(std::string("Unable to locate or access the required datafile. Filespec: " + filespec))
       {}
    };


    class bad_field_count : public std::out_of_range
    {
     public:
       bad_field_count(const std::string& s) :
         std::out_of_range(s)
      {}
    };
# 147 "/usr/include/boost/date_time/tz_db_base.hpp" 3 4
    template<class time_zone_type, class rule_type>
    class tz_db_base {
    public:
# 158 "/usr/include/boost/date_time/tz_db_base.hpp" 3 4
      typedef char char_type;

      typedef typename time_zone_type::base_type time_zone_base_type;
      typedef typename time_zone_type::time_duration_type time_duration_type;
      typedef time_zone_names_base<char_type> time_zone_names;
      typedef boost::date_time::dst_adjustment_offsets<time_duration_type> dst_adjustment_offsets;
      typedef std::basic_string<char_type> string_type;


      tz_db_base() {}



      void load_from_stream(std::istream &in)
      {
        std::string buff;
        while( std::getline(in, buff)) {
          parse_string(buff);
        }
      }



      void load_from_file(const std::string& pathspec)
      {
        string_type in_str;
        std::string buff;

        std::ifstream ifs(pathspec.c_str());
        if(!ifs){
          boost::throw_exception(data_not_accessible(pathspec));
        }
        std::getline(ifs, buff);
        this->load_from_stream(ifs);
      }





      bool add_record(const string_type& region,
                      boost::shared_ptr<time_zone_base_type> tz)
      {
        typename map_type::value_type p(region, tz);
        return (m_zone_map.insert(p)).second;
      }





      boost::shared_ptr<time_zone_base_type>
      time_zone_from_region(const string_type& region) const
      {

        typename map_type::const_iterator record = m_zone_map.find(region);
        if(record == m_zone_map.end()){
          return boost::shared_ptr<time_zone_base_type>();
        }
        return record->second;
      }


      std::vector<std::string> region_list() const
      {
        typedef std::vector<std::string> vector_type;
        vector_type regions;
        typename map_type::const_iterator itr = m_zone_map.begin();
        while(itr != m_zone_map.end()) {
          regions.push_back(itr->first);
          ++itr;
        }
        return regions;
      }

    private:
      typedef std::map<string_type, boost::shared_ptr<time_zone_base_type> > map_type;
      map_type m_zone_map;


      typedef typename rule_type::start_rule::week_num week_num;






      rule_type* parse_rules(const string_type& sr, const string_type& er) const
      {
        using namespace gregorian;


        typedef typename rule_type::start_rule start_rule;
        typedef typename rule_type::end_rule end_rule;


        int s_nth = 0, s_d = 0, s_m = 0;
        int e_nth = 0, e_d = 0, e_m = 0;
        split_rule_spec(s_nth, s_d, s_m, sr);
        split_rule_spec(e_nth, e_d, e_m, er);

        typename start_rule::week_num s_wn, e_wn;
        s_wn = get_week_num(s_nth);
        e_wn = get_week_num(e_nth);


        return new rule_type(start_rule(s_wn, s_d, s_m),
                             end_rule(e_wn, e_d, e_m));
      }

      week_num get_week_num(int nth) const
      {
        typedef typename rule_type::start_rule start_rule;
        switch(nth){
        case 1:
          return start_rule::first;
        case 2:
          return start_rule::second;
        case 3:
          return start_rule::third;
        case 4:
          return start_rule::fourth;
        case 5:
        case -1:
          return start_rule::fifth;
        default:

          break;
        }
        return start_rule::fifth;
      }


      void split_rule_spec(int& nth, int& d, int& m, string_type rule) const
      {
        typedef boost::char_separator<char_type, std::char_traits<char_type> > char_separator_type;
        typedef boost::tokenizer<char_separator_type,
                                 std::basic_string<char_type>::const_iterator,
                                 std::basic_string<char_type> > tokenizer;
        typedef boost::tokenizer<char_separator_type,
                                 std::basic_string<char_type>::const_iterator,
                                 std::basic_string<char_type> >::iterator tokenizer_iterator;

        const char_type sep_char[] = { ';', '\0'};
        char_separator_type sep(sep_char);
        tokenizer tokens(rule, sep);

        tokenizer_iterator tok_iter = tokens.begin();
        nth = std::atoi(tok_iter->c_str()); ++tok_iter;
        d = std::atoi(tok_iter->c_str()); ++tok_iter;
        m = std::atoi(tok_iter->c_str());
      }







      bool parse_string(string_type& s)
      {
        std::vector<string_type> result;
        typedef boost::token_iterator_generator<boost::escaped_list_separator<char_type>, string_type::const_iterator, string_type >::type token_iter_type;

        token_iter_type i = boost::make_token_iterator<string_type>(s.begin(), s.end(),boost::escaped_list_separator<char_type>());

        token_iter_type end;
        while (i != end) {
          result.push_back(*i);
          i++;
        }

        enum db_fields { ID, STDABBR, STDNAME, DSTABBR, DSTNAME, GMTOFFSET,
                         DSTADJUST, START_DATE_RULE, START_TIME, END_DATE_RULE,
                         END_TIME, FIELD_COUNT };


        const unsigned int expected_fields = static_cast<unsigned int>(FIELD_COUNT);
        if (result.size() != expected_fields) {
          std::ostringstream msg;
          msg << "Expecting " << FIELD_COUNT << " fields, got "
            << result.size() << " fields in line: " << s;
          boost::throw_exception(bad_field_count(msg.str()));
          std::abort();
        }


        bool has_dst = true;
        if(result[DSTABBR] == std::string()){
          has_dst = false;
        }



        time_zone_names names(result[STDNAME], result[STDABBR],
                              result[DSTNAME], result[DSTABBR]);

        time_duration_type utc_offset =
          str_from_delimited_time_duration<time_duration_type,char_type>(result[GMTOFFSET]);

        dst_adjustment_offsets adjust(time_duration_type(0,0,0),
                                      time_duration_type(0,0,0),
                                      time_duration_type(0,0,0));

        boost::shared_ptr<rule_type> rules;

        if(has_dst){
          adjust = dst_adjustment_offsets(
                                          str_from_delimited_time_duration<time_duration_type,char_type>(result[DSTADJUST]),
                                          str_from_delimited_time_duration<time_duration_type,char_type>(result[START_TIME]),
                                          str_from_delimited_time_duration<time_duration_type,char_type>(result[END_TIME])
                                          );

          rules =
            boost::shared_ptr<rule_type>(parse_rules(result[START_DATE_RULE],
                                                     result[END_DATE_RULE]));
        }
        string_type id(result[ID]);
        boost::shared_ptr<time_zone_base_type> zone(new time_zone_type(names, utc_offset, adjust, rules));
        return (add_record(id, zone));

      }

    };

} }
# 15 "/usr/include/boost/date_time/local_time/tz_database.hpp" 2 3 4


namespace boost {
namespace local_time {

  using date_time::data_not_accessible;
  using date_time::bad_field_count;





  typedef date_time::tz_db_base<custom_time_zone, nth_kday_dst_rule> tz_database;

}}
# 20 "/usr/include/boost/date_time/local_time/local_time.hpp" 2 3 4
# 16 "/usr/include/boost/date_time.hpp" 2 3 4
# 22 "./drizzled/internal/my_pthread.h" 2
# 40 "./drizzled/internal/my_pthread.h"
namespace drizzled {
namespace internal {
# 101 "./drizzled/internal/my_pthread.h"
__attribute__ ((visibility("default"))) void my_thread_init();

}
}
# 34 "./drizzled/internal/my_sys.h" 2

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stdarg.h" 1 3 4
# 36 "./drizzled/internal/my_sys.h" 2
# 46 "./drizzled/internal/my_sys.h"
# 1 "/usr/include/i386-linux-gnu/sys/mman.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/sys/mman.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 26 "/usr/include/i386-linux-gnu/sys/mman.h" 2 3 4
# 41 "/usr/include/i386-linux-gnu/sys/mman.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/mman.h" 1 3 4
# 42 "/usr/include/i386-linux-gnu/sys/mman.h" 2 3 4




extern "C" {
# 61 "/usr/include/i386-linux-gnu/sys/mman.h" 3 4
extern void * mmap (void *__addr, size_t __len, int __prot, int __flags, int __fd, __off64_t __offset) throw () __asm__ ("" "mmap64")


                ;





extern void *mmap64 (void *__addr, size_t __len, int __prot,
       int __flags, int __fd, __off64_t __offset) throw ();




extern int munmap (void *__addr, size_t __len) throw ();




extern int mprotect (void *__addr, size_t __len, int __prot) throw ();







extern int msync (void *__addr, size_t __len, int __flags);




extern int madvise (void *__addr, size_t __len, int __advice) throw ();



extern int posix_madvise (void *__addr, size_t __len, int __advice) throw ();




extern int mlock (const void *__addr, size_t __len) throw ();


extern int munlock (const void *__addr, size_t __len) throw ();




extern int mlockall (int __flags) throw ();



extern int munlockall (void) throw ();







extern int mincore (void *__start, size_t __len, unsigned char *__vec)
     throw ();
# 133 "/usr/include/i386-linux-gnu/sys/mman.h" 3 4
extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
       int __flags, ...) throw ();



extern int remap_file_pages (void *__start, size_t __size, int __prot,
        size_t __pgoff, int __flags) throw ();




extern int shm_open (const char *__name, int __oflag, mode_t __mode);


extern int shm_unlink (const char *__name);

}
# 47 "./drizzled/internal/my_sys.h" 2


# 1 "./drizzled/qsort_cmp.h" 1
# 20 "./drizzled/qsort_cmp.h"
       

namespace drizzled
{


typedef int (*qsort_cmp)(const void *,const void *);
typedef int (*qsort_cmp2)(void*, const void *,const void *);
typedef int (*qsort2_cmp)(const void *, const void *, const void *);

}
# 50 "./drizzled/internal/my_sys.h" 2



namespace drizzled {
namespace internal {
# 106 "./drizzled/internal/my_sys.h"
typedef uint64_t my_off_t;

extern char *home_dir;
extern const char *my_progname;

extern __attribute__ ((visibility("default"))) int my_umask,
    my_umask_dir;
extern bool my_use_symdir;

extern uint32_t my_default_record_cache_size;
extern bool my_disable_symlinks;
extern const char wild_many, wild_one, wild_prefix;
extern const char *charsets_dir;

extern bool timed_mutexes;

enum cache_type
{
  TYPE_NOT_SET= 0,
  READ_CACHE,
  WRITE_CACHE,
  READ_FIFO,
  READ_NET,
  WRITE_NET
};

typedef struct record_cache
{
public:
  int file;
  int rc_seek,error,inited;
  uint rc_length,read_length,reclength;
  my_off_t rc_record_pos,end_of_file;
  unsigned char *rc_buff,*rc_buff2,*rc_pos,*rc_end,*rc_request_pos;
  enum cache_type type;

  record_cache():
    file(0),
    rc_seek(0),
    error(0),
    inited(0),
    rc_length(0),
    read_length(0),
    reclength(0),
    rc_record_pos(0),
    end_of_file(0),
    rc_buff(__null),
    rc_buff2(__null),
    rc_pos(__null),
    rc_end(__null),
    rc_request_pos(__null)
  {}

} RECORD_CACHE;



extern int my_copy(const char *from,const char *to,myf MyFlags);
__attribute__ ((visibility("default"))) int my_delete(const char *name,myf MyFlags);
__attribute__ ((visibility("default"))) int my_open(const char *FileName,int Flags,myf MyFlags);
extern int my_register_filename(int fd, const char *FileName, uint32_t error_message_number, myf MyFlags);
__attribute__ ((visibility("default"))) int my_create(const char *FileName,int CreateFlags, int AccessFlags, myf MyFlags);
__attribute__ ((visibility("default"))) int my_close(int Filedes,myf MyFlags);
extern int my_mkdir(const char *dir, int Flags, myf MyFlags);
extern int my_realpath(char *to, const char *filename, myf MyFlags);
extern int my_create_with_symlink(const char *linkname, const char *filename,
                                  int createflags, int access_flags, myf MyFlags);
__attribute__ ((visibility("default"))) int my_delete_with_symlink(const char *name, myf MyFlags);
extern int my_rename_with_symlink(const char *from,const char *to,myf MyFlags);
__attribute__ ((visibility("default"))) size_t my_read(int Filedes,unsigned char *Buffer,size_t Count,myf MyFlags);
__attribute__ ((visibility("default"))) int my_rename(const char *from, const char *to,myf MyFlags);
__attribute__ ((visibility("default"))) size_t my_write(int Filedes, const unsigned char *Buffer, size_t Count, myf MyFlags);

extern int check_if_legal_tablename(const char *path);

__attribute__ ((visibility("default"))) int my_sync(int fd, myf my_flags);
extern int my_sync_dir(const char *dir_name, myf my_flags);
extern int my_sync_dir_by_file(const char *file_name, myf my_flags);
extern void my_init();
extern void my_end();
extern int my_redel(const char *from, const char *to, int MyFlags);
extern int my_copystat(const char *from, const char *to, int MyFlags);

extern void my_remember_signal(int signal_number,void (*func)(int));
extern size_t dirname_part(char * to,const char *name, size_t *to_res_length);
extern size_t dirname_length(const char *name);

bool test_if_hard_path(const char *dir_name);

extern char *convert_dirname(char *to, const char *from, const char *from_end);
extern char * fn_ext(const char *name);
extern char * fn_same(char * toname,const char *name,int flag);
__attribute__ ((visibility("default"))) char * fn_format(char * to,const char *name,const char *dir, const char *form, uint32_t flag);
extern size_t unpack_dirname(char * to,const char *from);
extern size_t unpack_filename(char * to,const char *from);
extern char * intern_filename(char * to,const char *from);
extern int pack_filename(char * to, const char *name, size_t max_length);
extern char * my_load_path(char * to, const char *path, const char *own_path_prefix);
extern void my_string_ptr_sort(unsigned char *base,uint32_t items,size_t size);
extern void radixsort_for_str_ptr(unsigned char* base[], uint32_t number_of_elements, size_t size_of_element,unsigned char *buffer[]);
extern void my_qsort(void *base_ptr, size_t total_elems, size_t size, qsort_cmp cmp);
extern void my_qsort2(void *base_ptr, size_t total_elems, size_t size, qsort2_cmp cmp, void *cmp_argument);
extern qsort2_cmp get_ptr_compare(size_t);
__attribute__ ((visibility("default"))) void my_store_ptr(unsigned char *buff, size_t pack_length, my_off_t pos);
__attribute__ ((visibility("default"))) my_off_t my_get_ptr(unsigned char *ptr, size_t pack_length);
int create_temp_file(char *to, const char *dir, const char *pfx, myf MyFlags);

}
}
# 31 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/item/cache_int.h" 1
# 20 "./drizzled/item/cache_int.h"
       

# 1 "./drizzled/item/cache.h" 1
# 20 "./drizzled/item/cache.h"
       

# 1 "./drizzled/item/basic_constant.h" 1
# 20 "./drizzled/item/basic_constant.h"
       

# 1 "./drizzled/item.h" 1
# 22 "./drizzled/item.h"
       

# 1 "./drizzled/dtcollation.h" 1
# 20 "./drizzled/dtcollation.h"
       





namespace drizzled {

class __attribute__ ((visibility("default"))) DTCollation
{
public:
  const charset_info_st* collation;
  Derivation derivation;

  __attribute__ ((visibility("hidden"))) DTCollation();
  __attribute__ ((visibility("hidden"))) DTCollation(const charset_info_st*, Derivation);
  void set(DTCollation &dt);
  void set(const charset_info_st*, Derivation);
  void set(const charset_info_st*);
  void set(Derivation derivation_arg);
  bool set(DTCollation &dt1, DTCollation &dt2, uint32_t flags= 0);
# 78 "./drizzled/dtcollation.h"
  __attribute__ ((visibility("hidden"))) bool aggregate(DTCollation &dt, uint32_t flags= 0);

  __attribute__ ((visibility("hidden"))) const char *derivation_name() const;

};


bool agg_item_collations(DTCollation &c, const char *name,
                         Item **items, uint32_t nitems,
                         uint32_t flags, int item_sep);
bool agg_item_collations_for_comparison(DTCollation &c, const char *name,
                                        Item **items, uint32_t nitems,
                                        uint32_t flags);
# 125 "./drizzled/dtcollation.h"
bool agg_item_charsets(DTCollation &c, const char *name,
                       Item **items, uint32_t nitems, uint32_t flags,
                       int item_sep);


void my_coll_agg_error(DTCollation &c1, DTCollation &c2, const char *fname);
void my_coll_agg_error(DTCollation &c1, DTCollation &c2, DTCollation &c3,
                       const char *fname);
void my_coll_agg_error(Item** args, uint32_t count, const char *fname,
                       int item_sep);

}
# 25 "./drizzled/item.h" 2
# 1 "./drizzled/charset.h" 1
# 24 "./drizzled/charset.h"
       


# 1 "/usr/include/c++/4.8/cstddef" 1 3
# 39 "/usr/include/c++/4.8/cstddef" 3
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 28 "./drizzled/charset.h" 2





namespace drizzled {
# 110 "./drizzled/charset.h"
typedef int (*my_charset_conv_mb_wc)(const charset_info_st*, unsigned long *, const unsigned char*, const unsigned char *);
typedef int (*my_charset_conv_wc_mb)(const charset_info_st*, unsigned long, unsigned char*, unsigned char *);
typedef size_t (*my_charset_conv_case)(const charset_info_st*, char*, size_t, char*, size_t);

struct MY_UNICASE_INFO
{
  uint16_t toupper;
  uint16_t tolower;
  uint16_t sort;
};

struct MY_UNI_CTYPE
{
  unsigned char pctype;
  unsigned char* ctype;
};

struct MY_UNI_IDX
{
  uint16_t from;
  uint16_t to;
  unsigned char *tab;
};

struct my_match_t
{
  uint32_t beg;
  uint32_t end;
  uint32_t mb_len;
};

enum my_lex_states
{
  MY_LEX_START, MY_LEX_CHAR, MY_LEX_IDENT,
  MY_LEX_IDENT_SEP, MY_LEX_IDENT_START,
  MY_LEX_REAL, MY_LEX_HEX_NUMBER, MY_LEX_BIN_NUMBER,
  MY_LEX_CMP_OP, MY_LEX_LONG_CMP_OP, MY_LEX_STRING, MY_LEX_COMMENT, MY_LEX_END,
  MY_LEX_OPERATOR_OR_IDENT, MY_LEX_NUMBER_IDENT, MY_LEX_INT_OR_REAL,
  MY_LEX_REAL_OR_POINT, MY_LEX_BOOL, MY_LEX_EOL, MY_LEX_ESCAPE,
  MY_LEX_LONG_COMMENT, MY_LEX_END_LONG_COMMENT, MY_LEX_SEMICOLON,
  MY_LEX_SET_VAR, MY_LEX_USER_END, MY_LEX_HOSTNAME, MY_LEX_SKIP,
  MY_LEX_USER_VARIABLE_DELIMITER, MY_LEX_SYSTEM_VAR,
  MY_LEX_IDENT_OR_KEYWORD,
  MY_LEX_IDENT_OR_HEX, MY_LEX_IDENT_OR_BIN,
  MY_LEX_STRING_OR_DELIMITER
};


struct MY_COLLATION_HANDLER
{
  bool (*init)(charset_info_st&, unsigned char *(*alloc)(size_t));

  int (*strnncoll)(const charset_info_st*, const unsigned char*, size_t, const unsigned char*, size_t, bool);
  int (*strnncollsp)(const charset_info_st*, const unsigned char*, size_t, const unsigned char*, size_t, bool diff_if_only_endspace_difference);
  size_t (*strnxfrm)(const charset_info_st*, unsigned char *dst, size_t dstlen, uint32_t nweights, const unsigned char *src, size_t srclen, uint32_t flags);
  size_t (*strnxfrmlen)(const charset_info_st*, size_t);
  bool (*like_range)(const charset_info_st*, const char *s, size_t s_length, char escape, char w_one, char w_many,
    size_t res_length, char *min_str, char *max_str, size_t *min_len, size_t *max_len);
  int (*wildcmp)(const charset_info_st*, const char *str,const char *str_end, const char *wildstr, const char *wildend, int escape,int w_one, int w_many);

  int (*strcasecmp)(const charset_info_st*, const char*, const char *);

  uint32_t (*instr)(const charset_info_st*, const char *b, size_t b_length, const char *s, size_t s_length, my_match_t *match, uint32_t nmatch);


  void (*hash_sort)(const charset_info_st*, const unsigned char *key, size_t len, uint32_t *nr1, uint32_t *nr2);
  bool (*propagate)();
};


struct MY_CHARSET_HANDLER
{

  uint32_t (*ismbchar)(const charset_info_st*, const char*, const char *);
  uint32_t (*mbcharlen)(const charset_info_st*, uint32_t c);
  size_t (*numchars)(const charset_info_st*, const char *b, const char *e);
  size_t (*charpos)(const charset_info_st*, const char *b, const char *e, size_t pos);
  size_t (*well_formed_len)(const charset_info_st&, str_ref, size_t nchars, int *error);
  size_t (*lengthsp)(const charset_info_st*, const char *ptr, size_t length);
  size_t (*numcells)(const charset_info_st*, const char *b, const char *e);


  my_charset_conv_mb_wc mb_wc;
  my_charset_conv_wc_mb wc_mb;


  int (*ctype)(const charset_info_st *cs, int *ctype, const unsigned char *s, const unsigned char *e);


  size_t (*caseup_str)(const charset_info_st*, char *);
  size_t (*casedn_str)(const charset_info_st*, char *);

  my_charset_conv_case caseup;
  my_charset_conv_case casedn;


  size_t (*snprintf)(const charset_info_st*, char *to, size_t n, const char *fmt, ...)

                         __attribute__((format(printf, 4, 5)))

                         ;
  size_t (*long10_to_str)(const charset_info_st*, char *to, size_t n, int radix, long int val);
  size_t (*int64_t10_to_str)(const charset_info_st*, char *to, size_t n, int radix, int64_t val);

  void (*fill)(const charset_info_st*, char *to, size_t len, int fill);


  long (*strntol)(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
  unsigned long (*strntoul)(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
  int64_t (*strntoll)(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
  uint64_t (*strntoull)(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
  double (*strntod)(const charset_info_st*, char *s, size_t l, char **e, int *err);
  int64_t (*strtoll10)(const charset_info_st*, const char *nptr, char **endptr, int *error);
  uint64_t (*strntoull10rnd)(const charset_info_st*, const char *str, size_t length, int unsigned_fl, char **endptr, int *error);
  size_t (*scan)(const charset_info_st*, const char *b, const char *e, int sq);
};


struct charset_info_st
{
  uint32_t number;
  uint32_t primary_number;
  uint32_t binary_number;
  uint32_t state;
  const char *csname;
  const char *name;
  const char *comment;
  const char *tailoring;
  unsigned char *ctype;
  unsigned char *to_lower;
  unsigned char *to_upper;
  unsigned char *sort_order;
  uint16_t *contractions;
  uint16_t **sort_order_big;
  uint16_t *tab_to_uni;
  MY_UNI_IDX *tab_from_uni;
  MY_UNICASE_INFO **caseinfo;
  unsigned char *state_map;
  unsigned char *ident_map;
  uint32_t strxfrm_multiply;
  unsigned char caseup_multiply;
  unsigned char casedn_multiply;
  uint32_t mbminlen;
  uint32_t mbmaxlen;
  uint16_t min_sort_char;
  uint16_t max_sort_char;
  unsigned char pad_char;
  unsigned char levels_for_compare;
  unsigned char levels_for_order;

  MY_CHARSET_HANDLER *cset;
  MY_COLLATION_HANDLER *coll;

  bool isalpha(unsigned char c) const
  {
    return ctype[c + 1] & (01 | 02);
  }

  bool isupper(unsigned char c) const
  {
    return ctype[c + 1] & 01;
  }

  bool islower(unsigned char c) const
  {
    return ctype[c + 1] & 02;
  }

  bool isdigit(unsigned char c) const
  {
    return ctype[c + 1] & 04;
  }

  bool isxdigit(unsigned char c) const
  {
    return ctype[c + 1] & 0200;
  }

  bool isalnum(unsigned char c) const
  {
    return ctype[c + 1] & (01 | 02 | 04);
  }

  bool isspace(unsigned char c) const
  {
    return ctype[c + 1] & 010;
  }

  bool ispunct(unsigned char c) const
  {
    return ctype[c + 1] & 020;
  }

  bool isprint(unsigned char c) const
  {
    return ctype[c + 1] & (020 | 01 | 02 | 04 | 0100);
  }

  bool isgraph(unsigned char c) const
  {
    return ctype[c + 1] & (020 | 01 | 02 | 04);
  }

  bool iscntrl(unsigned char c) const
  {
    return ctype[c + 1] & 040;
  }

  bool isvar(char c) const
  {
    return isalnum(c) || (c) == '_';
  }

  char toupper(unsigned char c) const
  {
    return to_upper[c];
  }

  char tolower(unsigned char c) const
  {
    return to_lower[c];
  }

  bool binary_compare() const
  {
    return state & 16;
  }

  bool use_strnxfrm() const
  {
    return state & 64;
  }

  size_t strnxfrm(unsigned char *dst, const size_t dstlen, const unsigned char *src, const uint32_t srclen) const
  {
    return coll->strnxfrm(this, dst, dstlen, dstlen, src, srclen, 0x00000040);
  }

  int strcasecmp(const char *s, const char *t) const
  {
    return coll->strcasecmp(this, s, t);
  }

  size_t caseup_str(char* src) const
  {
    return cset->caseup_str(this, src);
  }

  size_t casedn_str(char* src) const
  {
    return cset->casedn_str(this, src);
  }
};

extern __attribute__ ((visibility("default"))) charset_info_st *all_charsets[256];
uint32_t get_charset_number(const char *cs_name, uint32_t cs_flags);
uint32_t get_collation_number(const char *name);
const char *get_charset_name(uint32_t cs_number);
void free_charsets();
bool my_charset_same(const charset_info_st*, const charset_info_st*);
size_t escape_string_for_drizzle(const charset_info_st *charset_info, char *to, size_t to_length, const char *from, size_t length);
size_t escape_quotes_for_drizzle(const charset_info_st *charset_info, char *to, size_t to_length, const char *from, size_t length);
extern __attribute__ ((visibility("default"))) const charset_info_st *default_charset_info;
extern __attribute__ ((visibility("default"))) const charset_info_st *system_charset_info;
extern const charset_info_st *files_charset_info;
extern const charset_info_st *table_alias_charset;
extern MY_UNICASE_INFO *my_unicase_default[256];
extern MY_UNICASE_INFO *my_unicase_turkish[256];
extern MY_UNI_CTYPE my_uni_ctype[256];
extern __attribute__ ((visibility("default"))) charset_info_st my_charset_bin;
extern __attribute__ ((visibility("default"))) charset_info_st my_charset_utf8mb4_bin;
extern __attribute__ ((visibility("default"))) charset_info_st my_charset_utf8mb4_general_ci;
extern __attribute__ ((visibility("default"))) charset_info_st my_charset_utf8mb4_unicode_ci;
size_t my_strnxfrmlen_simple(const charset_info_st*, size_t);
int my_strnncollsp_simple(const charset_info_st*, const unsigned char*, size_t, const unsigned char*, size_t, bool diff_if_only_endspace_difference);
size_t my_lengthsp_8bit(const charset_info_st*, const char *ptr, size_t length);
uint32_t my_instr_simple(const charset_info_st*, const char *b, size_t b_length, const char *s, size_t s_length, my_match_t *match, uint32_t nmatch);
int my_strcasecmp_mb(const charset_info_st*, const char *s, const char *t);

__attribute__ ((visibility("default"))) const charset_info_st *get_charset(uint32_t cs_number);
__attribute__ ((visibility("default"))) const charset_info_st *get_charset_by_name(const char *cs_name);
__attribute__ ((visibility("default"))) const charset_info_st *get_charset_by_csname(const char *cs_name, uint32_t cs_flags);


int my_mb_ctype_8bit(const charset_info_st*, int*, const unsigned char*, const unsigned char *);
int my_mb_ctype_mb(const charset_info_st*, int*, const unsigned char*, const unsigned char *);

size_t my_scan_8bit(const charset_info_st*, const char *b, const char *e, int sq);
size_t my_snprintf_8bit(const charset_info_st*, char *to, size_t n, const char *fmt, ...) __attribute__((format(printf, 4, 5)));

long my_strntol_8bit(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
unsigned long my_strntoul_8bit(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
int64_t my_strntoll_8bit(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
uint64_t my_strntoull_8bit(const charset_info_st*, const char *s, size_t l, int base, char **e, int *err);
double my_strntod_8bit(const charset_info_st*, char *s, size_t l,char **e, int *err);
size_t my_long10_to_str_8bit(const charset_info_st*, char *to, size_t l, int radix, long int val);
size_t my_int64_t10_to_str_8bit(const charset_info_st*, char *to, size_t l, int radix, int64_t val);
int64_t my_strtoll10_8bit(const charset_info_st*, const char *nptr, char **endptr, int *error);

uint64_t my_strntoull10rnd_8bit(const charset_info_st*, const char *str, size_t length, int unsigned_fl, char **endptr, int *error);

void my_fill_8bit(const charset_info_st*, char* to, size_t l, int fill);

bool my_like_range_simple(const charset_info_st*,
         const char *ptr, size_t ptr_length,
         char escape, char w_one, char w_many,
         size_t res_length,
         char *min_str, char *max_str,
         size_t *min_length, size_t *max_length);

bool my_like_range_mb(const charset_info_st*,
     const char *ptr, size_t ptr_length,
     char escape, char w_one, char w_many,
     size_t res_length,
     char *min_str, char *max_str,
     size_t *min_length, size_t *max_length);

int my_wildcmp_8bit(const charset_info_st*,
      const char *str,const char *str_end,
      const char *wildstr,const char *wildend,
      int escape, int w_one, int w_many);

int my_wildcmp_bin(const charset_info_st*,
     const char *str,const char *str_end,
     const char *wildstr,const char *wildend,
     int escape, int w_one, int w_many);

size_t my_numchars_8bit(const charset_info_st*, const char *b, const char *e);
size_t my_numcells_8bit(const charset_info_st*, const char *b, const char *e);
size_t my_charpos_8bit(const charset_info_st*, const char *b, const char *e, size_t pos);
size_t my_well_formed_len_8bit(const charset_info_st&, str_ref, size_t pos, int *error);
typedef unsigned char *(*cs_alloc_func)(size_t);
bool my_coll_init_simple(charset_info_st *cs, cs_alloc_func alloc);
bool my_cset_init_8bit(charset_info_st *cs, cs_alloc_func alloc);
uint32_t my_mbcharlen_8bit(const charset_info_st*, uint32_t c);


int my_wildcmp_mb(const charset_info_st*,
    const char *str,const char *str_end,
    const char *wildstr,const char *wildend,
    int escape, int w_one, int w_many);
size_t my_numchars_mb(const charset_info_st*, const char *b, const char *e);
size_t my_numcells_mb(const charset_info_st*, const char *b, const char *e);
size_t my_charpos_mb(const charset_info_st*, const char *b, const char *e, size_t pos);
size_t my_well_formed_len_mb(const charset_info_st&, str_ref, size_t pos, int *error);
uint32_t my_instr_mb(const charset_info_st*,
                 const char *b, size_t b_length,
                 const char *s, size_t s_length,
                 my_match_t *match, uint32_t nmatch);

int my_strnncoll_mb_bin(const charset_info_st* cs,
                        const unsigned char *s, size_t slen,
                        const unsigned char *t, size_t tlen,
                        bool t_is_prefix);

int my_strnncollsp_mb_bin(const charset_info_st*,
                          const unsigned char *a, size_t a_length,
                          const unsigned char *b, size_t b_length,
                          bool diff_if_only_endspace_difference);

int my_wildcmp_mb_bin(const charset_info_st*,
                      const char *str,const char *str_end,
                      const char *wildstr,const char *wildend,
                      int escape, int w_one, int w_many);

int my_strcasecmp_mb_bin(const charset_info_st*, const char *s, const char *t);

void my_hash_sort_mb_bin(const charset_info_st*,
                         const unsigned char *key, size_t len, uint32_t *nr1, uint32_t *nr2);

size_t my_strnxfrm_mb(const charset_info_st*,
                      unsigned char *dst, size_t dstlen, uint32_t nweights,
                      const unsigned char *src, size_t srclen, uint32_t flags);

int my_wildcmp_unicode(const charset_info_st*,
                       const char *str, const char *str_end,
                       const char *wildstr, const char *wildend,
                       int escape, int w_one, int w_many,
                       MY_UNICASE_INFO **weights);

bool my_propagate_simple();
bool my_propagate_complex();


uint32_t my_strxfrm_flag_normalize(uint32_t flags, uint32_t nlevels);
void my_strxfrm_desc_and_reverse(unsigned char *str, unsigned char *strend,
                                 uint32_t flags, uint32_t level);
size_t my_strxfrm_pad_desc_and_reverse(const charset_info_st*,
                                       unsigned char *str, unsigned char *frmend, unsigned char *strend,
                                       uint32_t nweights, uint32_t flags, uint32_t level);

bool my_charset_is_ascii_compatible(const charset_info_st*);
# 519 "./drizzled/charset.h"
int my_wc_mb_filename(const charset_info_st*, unsigned long wc, unsigned char *s, unsigned char *e);
int my_mb_wc_filename(const charset_info_st*, unsigned long *pwc, const unsigned char *s, const unsigned char *e);

int my_strnncoll_8bit_bin(const charset_info_st*,
                          const unsigned char *s, size_t slen,
                          const unsigned char *t, size_t tlen,
                          bool t_is_prefix);
int my_strnncollsp_8bit_bin(const charset_info_st*,
                            const unsigned char *a, size_t a_length,
                            const unsigned char *b, size_t b_length,
                            bool diff_if_only_endspace_difference);
size_t my_case_str_bin(const charset_info_st*, char *);
size_t my_case_bin(const charset_info_st*, char*,
                   size_t srclen, char*, size_t);
int my_strcasecmp_bin(const charset_info_st*,
                      const char *s, const char *t);
size_t my_strnxfrm_8bit_bin(const charset_info_st*,
                     unsigned char * dst, size_t dstlen, uint32_t nweights,
                     const unsigned char *src, size_t srclen, uint32_t flags);
uint32_t my_instr_bin(const charset_info_st*,
                      const char *b, size_t b_length,
                      const char *s, size_t s_length,
                      my_match_t *match, uint32_t nmatch);
size_t my_lengthsp_binary(const charset_info_st*,
                          const char*, size_t length);
int my_mb_wc_bin(const charset_info_st*,
                 unsigned long *wc, const unsigned char *str,
                 const unsigned char *end);
int my_wc_mb_bin(const charset_info_st*, unsigned long wc,
                 unsigned char *str, unsigned char *end);
void my_hash_sort_8bit_bin(const charset_info_st*,
                           const unsigned char *key, size_t len,
                           uint32_t *nr1, uint32_t *nr2);
bool my_coll_init_8bit_bin(charset_info_st *cs,
                           cs_alloc_func);
int my_strnncoll_binary(const charset_info_st*,
                        const unsigned char *s, size_t slen,
                        const unsigned char *t, size_t tlen,
                        bool t_is_prefix);
int my_strnncollsp_binary(const charset_info_st*,
                          const unsigned char *s, size_t slen,
                          const unsigned char *t, size_t tlen,
                          bool);

inline static int my_strnncoll(const charset_info_st *cs,
                               const unsigned char *s,
                               const size_t slen,
                               const unsigned char *t,
                               const size_t tlen)
{
  return (cs->coll->strnncoll(cs, s, slen, t, tlen, 0));
}

inline static bool my_like_range(const charset_info_st *cs,
                                 const char *ptr, const size_t ptrlen,
                                 const char escape,
                                 const char w_one,
                                 const char w_many,
                                 const size_t reslen,
                                 char *minstr, char *maxstr,
                                 size_t *minlen, size_t *maxlen)
{
  return (cs->coll->like_range(cs, ptr, ptrlen, escape, w_one, w_many, reslen,
                               minstr, maxstr, minlen, maxlen));
}

inline static int my_wildcmp(const charset_info_st *cs,
                             const char *str, const char *strend,
                             const char *w_str, const char *w_strend,
                             const int escape,
                             const int w_one, const int w_many)
{
  return (cs->coll->wildcmp(cs, str, strend, w_str, w_strend, escape, w_one, w_many));
}

template <typename CHAR_T>
inline static size_t my_charpos(const charset_info_st *cs,
                                const CHAR_T *b, const CHAR_T* e, size_t num)
{
  return cs->cset->charpos(cs, reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(e), num);
}

inline static bool use_mb(const charset_info_st *cs)
{
  return cs->cset->ismbchar != __null;
}

inline static unsigned int my_ismbchar(const charset_info_st *cs, const char *a, const char *b)
{
  return cs->cset->ismbchar(cs, a, b);
}

inline static unsigned int my_mbcharlen(const charset_info_st *cs, uint32_t c)
{
  return cs->cset->mbcharlen(cs, c);
}


inline static long my_strntol(const charset_info_st *cs,
                              const char* s, const size_t l, const int base, char **e, int *err)
{
  return (cs->cset->strntol(cs, s, l, base, e, err));
}

inline static unsigned long my_strntoul(const charset_info_st *cs,
                                        const char* s, const size_t l, const int base,
                                        char **e, int *err)
{
  return (cs->cset->strntoul(cs, s, l, base, e, err));
}

inline static int64_t my_strntoll(const charset_info_st *cs,
                                 const char* s, const size_t l, const int base, char **e, int *err)
{
  return (cs->cset->strntoll(cs, s, l, base, e, err));
}

inline static int64_t my_strntoull(const charset_info_st *cs,
                                   const char* s, const size_t l, const int base,
                                   char **e, int *err)
{
  return (cs->cset->strntoull(cs, s, l, base, e, err));
}


inline static double my_strntod(const charset_info_st *cs,
                                char* s, const size_t l, char **e, int *err)
{
  return (cs->cset->strntod(cs, s, l, e, err));
}

int make_escape_code(const charset_info_st*, const char *escape);

}
# 26 "./drizzled/item.h" 2
# 1 "./drizzled/item_result.h" 1
# 21 "./drizzled/item_result.h"
       

enum Item_result
{
  STRING_RESULT=0,
  REAL_RESULT,
  INT_RESULT,
  ROW_RESULT,
  DECIMAL_RESULT
};
# 27 "./drizzled/item.h" 2

# 1 "./drizzled/sql_list.h" 1
# 20 "./drizzled/sql_list.h"
       

# 1 "/usr/include/c++/4.8/cstdlib" 1 3
# 39 "/usr/include/c++/4.8/cstdlib" 3
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 23 "./drizzled/sql_list.h" 2
# 1 "/usr/include/c++/4.8/cassert" 1 3
# 41 "/usr/include/c++/4.8/cassert" 3
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 24 "./drizzled/sql_list.h" 2





namespace drizzled {

struct SQL_LIST
{
  uint32_t elements;
  unsigned char *first;
  unsigned char **next;

  void clear()
  {
    elements=0;
    first=0;
    next= &first;
  }

  size_t size() const
  {
    return elements;
  }

  void link_in_list(unsigned char *element,unsigned char **next_ptr)
  {
    elements++;
    (*next)=element;
    next= next_ptr;
    *next=0;
  }
  void save_and_clear(SQL_LIST *save)
  {
    *save= *this;
    clear();
  }
  void push_front(SQL_LIST *save)
  {
    *save->next= first;
    first= save->first;
    elements+= save->elements;
  }
  void push_back(SQL_LIST *save)
  {
    if (save->first)
    {
      *next= save->first;
      next= save->next;
      elements+= save->elements;
    }
  }
};
# 94 "./drizzled/sql_list.h"
struct list_node : public memory::SqlAlloc
{
  list_node *next;
  void *info;
  list_node(void *info_par,list_node *next_par)
    :next(next_par),info(info_par)
  {}
  list_node()
  {
    info= 0;
    next= this;
  }
};

extern __attribute__ ((visibility("default"))) list_node end_of_list;

class base_list :public memory::SqlAlloc
{
protected:
  list_node *first,**last;
  uint32_t elements;
public:

  void clear() { elements=0; first= &end_of_list; last=&first;}
  base_list() { clear(); }
# 128 "./drizzled/sql_list.h"
  base_list(const base_list &tmp) :memory::SqlAlloc()
  {
    elements= tmp.elements;
    first= tmp.first;
    last= elements ? tmp.last : &first;
  }
  base_list(bool) { }
  void push_back(void *info)
  {
    *last = new list_node(info, &end_of_list);
    last= &(*last)->next;
    elements++;
  }
  void push_back(void *info, memory::Root& mem)
  {
    *last = new (mem) list_node(info, &end_of_list);
    last= &(*last)->next;
    elements++;
  }
  void push_front(void *info)
  {
    list_node *node=new list_node(info,first);
    if (last == &first)
   last= &node->next;
      first=node;
      elements++;
  }
  void remove(list_node **prev)
  {
    list_node *node=(*prev)->next;
    if (!--elements)
      last= &first;
    else if (last == &(*prev)->next)
      last= prev;
    delete *prev;
    *prev=node;
  }
  void concat(base_list *list)
  {
    if (!list->is_empty())
    {
      *last= list->first;
      last= list->last;
      elements+= list->elements;
    }
  }
  void *pop()
  {
    if (first == &end_of_list) return 0;
    list_node *tmp=first;
    first=first->next;
    if (!--elements)
      last= &first;
    return tmp->info;
  }
  void disjoin(base_list *list)
  {
    list_node **prev= &first;
    list_node *node= first;
    list_node *list_first= list->first;
    elements=0;
    while (node && node != list_first)
    {
      prev= &node->next;
      node= node->next;
      elements++;
    }
    *prev= *last;
    last= prev;
  }
  void prepand(base_list *list)
  {
    if (!list->is_empty())
    {
      *list->last= first;
      first= list->first;
      elements+= list->elements;
    }
  }



  void swap(base_list &rhs)
  {
    std::swap(first, rhs.first);
    std::swap(last, rhs.last);
    std::swap(elements, rhs.elements);
  }
  bool is_empty() { return first == &end_of_list ; }
  friend class base_list_iterator;
# 261 "./drizzled/sql_list.h"
protected:
  void after(void *info,list_node *node)
  {
    list_node *new_node=new list_node(info,node->next);
    node->next=new_node;
    elements++;
    if (last == &(node->next))
      last= &new_node->next;
  }
};


class base_list_iterator
{
protected:
  base_list *list;
  list_node **el,**prev,*current;
public:
  void sublist(base_list &ls, uint32_t elm) const
  {
    ls.first= *el;
    ls.last= list->last;
    ls.elements= elm;
  }
  base_list_iterator()
    :list(0), el(0), prev(0), current(0)
  {}

  base_list_iterator(base_list &list_par, list_node** el0)
    :list(&list_par), el(el0), prev(0), current(0)
  {
  }

  void *replace(base_list &new_list)
  {
    void *ret_value=current->info;
    if (!new_list.is_empty())
    {
      *new_list.last=current->next;
      current->info=new_list.first->info;
      current->next=new_list.first->next;
      if (list->last == &current->next && new_list.elements > 1)
        list->last= new_list.last;
      list->elements+=new_list.elements-1;
    }
    return ret_value;
  }
  void remove()
  {
    list->remove(prev);
    el=prev;
    current=0;
  }
  void after(void *element)
  {
    list->after(element,current);
    current=current->next;
    el= &current->next;
  }
};

template <class T> class List_iterator;

template <class T> class List : public base_list
{
public:
  typedef List_iterator<T> iterator;

  friend class List_iterator<T>;

  List() {}
  List(const List<T> &tmp) : base_list(tmp) {}
  List(const List<T> &tmp, memory::Root *mem_root) : base_list(tmp, mem_root) {}
  T& front() {return *static_cast<T*>(first->info); }
  T* pop() {return static_cast<T*>(base_list::pop()); }
  void concat(List<T> *list) { base_list::concat(list); }
  void disjoin(List<T> *list) { base_list::disjoin(list); }
  void prepand(List<T> *list) { base_list::prepand(list); }
  void delete_elements()
  {
    list_node *element,*next;
    for (element=first; element != &end_of_list; element=next)
    {
      next=element->next;
      delete (T*) element->info;
    }
    clear();
  }

  iterator begin()
  {
    return iterator(*this, &first);
  }

  size_t size() const
  {
    return elements;
  }

  void set_size(size_t v)
  {
    elements = v;
  }
};

template <class T> class List_iterator : public base_list_iterator
{
public:
  List_iterator(List<T>& a, list_node** b) : base_list_iterator(a, b) {};
  List_iterator() {};
  T *operator++(int) { prev=el; current= *el; el= &current->next; return (T*)current->info; }
  T *replace(T *a) { T* old = (T*) current->info; current->info= a; return old; }
  void replace(List<T> &a) { base_list_iterator::replace(a); }
  T** ref() { return (T**) &current->info; }

  T& operator*()
  {
    return *(T*)current->info;
  }

  T* operator->()
  {
    return (T*)current->info;
  }
};

}
# 29 "./drizzled/item.h" 2




namespace drizzled {
# 46 "./drizzled/item.h"
typedef bool (Item::*Item_analyzer) (unsigned char **argp);
typedef Item* (Item::*Item_transformer) (unsigned char *arg);
typedef void (*Cond_traverser) (const Item *item, void *arg);
typedef bool (Item::*Item_processor) (unsigned char *arg);






class __attribute__ ((visibility("default"))) Item : public memory::SqlAlloc, boost::noncopyable
{

  int8_t is_expensive_cache;
  virtual bool is_expensive_processor(unsigned char *arg);

public:

  enum Type
  {
    FIELD_ITEM= 0,
    FUNC_ITEM,
    SUM_FUNC_ITEM,
    STRING_ITEM,
    INT_ITEM,
    REAL_ITEM,
    NULL_ITEM,
    VARBIN_ITEM,
    COPY_STR_ITEM,
    FIELD_AVG_ITEM,
    DEFAULT_VALUE_ITEM,
    PROC_ITEM,
    COND_ITEM,
    REF_ITEM,
    FIELD_STD_ITEM,
    FIELD_VARIANCE_ITEM,
    INSERT_VALUE_ITEM,
    SUBSELECT_ITEM,
    ROW_ITEM, CACHE_ITEM,
    TYPE_HOLDER,
    PARAM_ITEM,
    BOOLEAN_ITEM,
    DECIMAL_ITEM
  };
  enum traverse_order
  {
    T_POSTFIX,
    T_PREFIX
  };
  enum cond_result
  {
    COND_UNDEF,
    COND_OK,
    COND_TRUE,
    COND_FALSE
  };





  String str_value;


  const char *name;


  uint32_t name_length;

  Item *next;
  uint32_t max_length;

  int8_t marker;
  uint8_t decimals;
  bool fixed;
  bool maybe_null;
  bool null_value;
  bool unsigned_flag;

  bool is_unsigned() const
  {
    return unsigned_flag;
  }

  virtual bool negative() const
  {
    return false;
  }

  bool with_sum_func;
  bool is_autogenerated_name;





  bool with_subselect;
  DTCollation collation;
  Item_result cmp_context;
# 153 "./drizzled/item.h"
  Item();
# 165 "./drizzled/item.h"
  Item(Session *session, Item *item);

  virtual ~Item()
  {
  }

  void set_name(str_ref arg)
  {
    set_name(arg.data(), arg.size());
  }

  void set_name(const char* arg)
  {
    set_name(str_ref(arg));
  }

  void set_name(const char *str, uint32_t length, const charset_info_st* cs= system_charset_info);
  void init_make_field(SendField *tmp_field, enum_field_types type);
  virtual void cleanup();
  virtual void make_field(SendField *field);
# 194 "./drizzled/item.h"
  Field *make_string_field(Table *table);
  virtual bool fix_fields(Session *, Item **);





  virtual void fix_after_pullout(Select_Lex *new_parent, Item **ref);





  inline void quick_fix_field()
  {
    fixed= true;
  }

  virtual int save_in_field(Field *field, bool no_conversions);
  virtual void save_org_in_field(Field *field)
  {
    (void) save_in_field(field, true);
  }
  virtual int save_safe_in_field(Field *field)
  {
    return save_in_field(field, true);
  }



  virtual void send(plugin::Client *client, String *str);
# 235 "./drizzled/item.h"
  virtual bool eq(const Item *, bool binary_cmp) const;
  virtual Item_result result_type() const
  {
    return REAL_RESULT;
  }
  virtual Item_result cast_to_int_type() const
  {
    return result_type();
  }
  virtual enum_field_types string_field_type() const;
  virtual enum_field_types field_type() const;
  virtual enum Type type() const =0;
# 284 "./drizzled/item.h"
  virtual int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
# 295 "./drizzled/item.h"
  virtual double val_real()=0;
# 304 "./drizzled/item.h"
  virtual int64_t val_int()=0;




  inline uint64_t val_uint()
  {
    return (uint64_t) val_int();
  }
# 348 "./drizzled/item.h"
  virtual String *val_str(String *str)=0;
# 368 "./drizzled/item.h"
  virtual type::Decimal *val_decimal(type::Decimal *decimal_buffer)= 0;
# 378 "./drizzled/item.h"
  virtual bool val_bool();


  String *val_string_from_real(String *str);
  String *val_string_from_int(String *str);
  String *val_string_from_decimal(String *str);
  type::Decimal *val_decimal_from_real(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_int(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_string(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_date(type::Decimal *decimal_value);
  type::Decimal *val_decimal_from_time(type::Decimal *decimal_value);
  int64_t val_int_from_decimal();
  double val_real_from_decimal();

  bool save_time_in_field(Field *field);
  bool save_date_in_field(Field *field);
# 412 "./drizzled/item.h"
  int save_str_value_in_field(Field *field, String *result);

  virtual Field *get_tmp_table_field(void)
  {
    return __null;
  }

  virtual Field *tmp_table_field(Table *t_arg);
  virtual const char *full_name(void) const;







  virtual double val_result()
  {
    return val_real();
  }
  virtual int64_t val_int_result()
  {
    return val_int();
  }
  virtual String *str_result(String* tmp)
  {
    return val_str(tmp);
  }
  virtual type::Decimal *val_decimal_result(type::Decimal *val)
  {
    return val_decimal(val);
  }
  virtual bool val_bool_result()
  {
    return val_bool();
  }



  virtual table_map used_tables() const
  {
    return (table_map) 0L;
  }
# 466 "./drizzled/item.h"
  virtual table_map not_null_tables() const
  {
    return used_tables();
  }




  virtual bool basic_const_item() const
  {
    return false;
  }

  virtual Item *clone_item()
  {
    return __null;
  }
  virtual cond_result eq_cmp_result() const
  {
    return COND_OK;
  }
  uint32_t float_length(uint32_t decimals_par) const;
  virtual uint32_t decimal_precision() const;
  int decimal_int_part() const;





  virtual bool const_item() const
  {
    return used_tables() == 0;
  }




  virtual bool const_during_execution() const
  {
    return (used_tables() & ~(((table_map) 1) << (sizeof(table_map)*8-3))) == 0;
  }
# 519 "./drizzled/item.h"
  virtual void print(String *str);

  void print_item_w_name(String *);
  virtual void update_used_tables() {}
  virtual void split_sum_func(Session *session,
                              Item **ref_pointer_array,
                              List<Item> &fields);
# 544 "./drizzled/item.h"
  void split_sum_func(Session *session,
                      Item **ref_pointer_array,
                      List<Item> &fields,
                      Item **ref,
                      bool skip_registered);





  virtual bool get_date(type::Time &ltime, uint32_t fuzzydate);





  virtual bool get_time(type::Time &ltime);
  virtual bool get_date_result(type::Time &ltime,uint32_t fuzzydate);
# 570 "./drizzled/item.h"
  virtual bool is_null();


  virtual void update_null_value ();
# 586 "./drizzled/item.h"
  virtual void top_level_item(void);




  virtual void set_result_field(Field *field);
  virtual bool is_result_field(void);
  virtual bool is_bool_func(void);
  virtual void save_in_result_field(bool no_conversions);




  virtual void no_rows_in_result(void);
  virtual Item *copy_or_same(Session *session);

  virtual Item *copy_andor_structure(Session *session);

  virtual Item *real_item(void);
  virtual const Item *real_item(void) const;
  virtual Item *get_tmp_table_item(Session *session);

  static const charset_info_st *default_charset();
  virtual const charset_info_st *compare_collation();

  virtual bool walk(Item_processor processor,
                    bool walk_subquery,
                    unsigned char *arg);
# 629 "./drizzled/item.h"
  virtual Item* transform(Item_transformer transformer, unsigned char *arg);
# 649 "./drizzled/item.h"
  virtual Item* compile(Item_analyzer analyzer,
                        unsigned char **arg_p,
                        Item_transformer transformer,
                        unsigned char *arg_t);

  virtual void traverse_cond(Cond_traverser traverser,
                             void *arg,
                             traverse_order order);

  virtual bool remove_dependence_processor(unsigned char * arg);
  virtual bool collect_item_field_processor(unsigned char * arg);
  virtual bool find_item_in_field_list_processor(unsigned char *arg);
  virtual bool change_context_processor(unsigned char *context);
  virtual bool register_field_in_read_map(unsigned char *arg);
  virtual bool subst_argument_checker(unsigned char **arg);

  virtual bool cache_const_expr_analyzer(unsigned char **arg);
  virtual Item* cache_const_expr_transformer(unsigned char *arg);

  virtual Item *equal_fields_propagator(unsigned char * arg);
  virtual bool set_no_const_sub(unsigned char *arg);
  virtual Item *replace_equal_field(unsigned char * arg);


  virtual uint32_t cols();
  virtual Item* element_index(uint32_t i);
  virtual Item** addr(uint32_t i);
  virtual bool check_cols(uint32_t c);

  virtual bool null_inside();

  virtual void bring_value();
# 693 "./drizzled/item.h"
  Field *tmp_table_field_from_field_type(Table *table, bool fixed_length);

  virtual Item *neg_transformer(Session *session);
  virtual Item *update_value_transformer(unsigned char *select_arg);
  virtual Item *safe_charset_converter(const charset_info_st * const tocs);
  void delete_self();







  virtual bool result_as_int64_t();
  bool is_datetime();
# 727 "./drizzled/item.h"
  virtual bool is_expensive();

  String *check_well_formed_result(String *str, bool send_error= 0);
# 750 "./drizzled/item.h"
  bool eq_by_collation(Item *item, bool binary_cmp, const charset_info_st * const cs);

  inline uint32_t char_to_byte_length_safe(uint32_t char_length_arg, uint32_t mbmaxlen_arg)
  {
    uint64_t tmp= ((uint64_t) char_length_arg) * mbmaxlen_arg;
    return (tmp > (4294967295U)) ? (uint32_t) (4294967295U) : (uint32_t) tmp;
  }

  uint32_t max_char_length() const;

  void fix_char_length(uint32_t max_char_length_arg);

protected:
  Session &getSession()
  {
    return _session;
  }

private:
  Session &_session;
};

namespace display {
const std::string &type(Item::Type type);
}

std::ostream& operator<<(std::ostream& output, const Item &item);

}


# 1 "./drizzled/item/ident.h" 1
# 20 "./drizzled/item/ident.h"
       



namespace drizzled {

class Item_ident : public Item
{
protected:






  const char *orig_db_name;
  const char *orig_table_name;
  const char *orig_field_name;

public:
  Name_resolution_context *context;
  const char *db_name;
  const char *table_name;
  const char *field_name;
  bool alias_name_used;





  uint32_t cached_field_index;





  TableList *cached_table;
  Select_Lex *depended_from;
  Item_ident(Name_resolution_context *context_arg,
             const char *db_name_arg, const char *table_name_arg,
             const char *field_name_arg);
  Item_ident(Session *session, Item_ident *item);
  const char *full_name() const;
  void cleanup();
  bool remove_dependence_processor(unsigned char * arg);
  virtual void print(String *str);
  virtual bool change_context_processor(unsigned char *cntx)
    { context= (Name_resolution_context *)cntx; return false; }
  friend bool insert_fields(Session *session, Name_resolution_context *context,
                            const char *db_name,
                            const char *table_name, List<Item>::iterator *it,
                            bool any_privileges);
};


class Item_ident_for_show : public Item
{
public:
  Field *field;
  const char *db_name;
  const char *table_name;

  Item_ident_for_show(Field *par_field, const char *db_arg,
                      const char *table_name_arg)
    :field(par_field), db_name(db_arg), table_name(table_name_arg)
  {}

  enum Type type() const { return FIELD_ITEM; }
  double val_real();
  int64_t val_int();
  String *val_str(String *str);
  type::Decimal *val_decimal(type::Decimal *dec);
  void make_field(SendField *tmp_field);
};

}
# 782 "./drizzled/item.h" 2

namespace drizzled
{
# 797 "./drizzled/item.h"
void mark_as_dependent(Session *session,
         Select_Lex *last,
                       Select_Lex *current,
                       Item_ident *resolved_item,
                       Item_ident *mark_item);
# 838 "./drizzled/item.h"
Item** resolve_ref_in_select_and_group(Session *session, Item_ident *ref, Select_Lex *select);
# 859 "./drizzled/item.h"
void mark_select_range_as_dependent(Session *session,
                                    Select_Lex *last_select,
                                    Select_Lex *current_sel,
                                    Field *found_field, Item *found_item,
                                    Item_ident *resolved_item);

extern void resolve_const_item(Session *session, Item **ref, Item *cmp_item);







extern bool field_is_equal_to_item(Field *field,Item *item);
# 908 "./drizzled/item.h"
Field *create_tmp_field(Session *session,
                        Table *table,
                        Item *item,
                        Item::Type type,
                        Item ***copy_func,
                        Field **from_field,
                        Field **def_field,
                        bool group,
                        bool modify_item,
                        bool make_copy_field,
                        uint32_t convert_blob_length);

}
# 23 "./drizzled/item/basic_constant.h" 2

namespace drizzled {

class Item_basic_constant : public Item
{
public:

  void cleanup()
  {
  }
};

}
# 23 "./drizzled/item/cache.h" 2
# 1 "./drizzled/item/field.h" 1
# 20 "./drizzled/item/field.h"
       



namespace drizzled {

class COND_EQUAL;

extern Item **not_found_item;

class Item_field :public Item_ident
{
protected:
  void set_field(Field *field);
public:
  Field *field,*result_field;
  Item_equal *item_equal;
  bool no_const_subst;




  uint32_t have_privileges;

  bool any_privileges;
  Item_field(Name_resolution_context *context_arg,
             const char *db_arg,const char *table_name_arg,
      const char *field_name_arg);



  Item_field(Session *session, Item_field *item);





  Item_field(Session *session, Name_resolution_context *context_arg, Field *field);





  Item_field(Field *field);
  enum Type type() const { return FIELD_ITEM; }
  bool eq(const Item *item, bool binary_cmp) const;
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  String *val_str(String*);
  double val_result();
  int64_t val_int_result();
  String *str_result(String* tmp);
  type::Decimal *val_decimal_result(type::Decimal *);
  bool val_bool_result();
  void send(plugin::Client *client, String *str_arg);
  void reset_field(Field *f);
  bool fix_fields(Session *, Item **);
  void fix_after_pullout(Select_Lex *new_parent, Item **ref);
  void make_field(SendField *tmp_field);
  int save_in_field(Field *field,bool no_conversions);
  void save_org_in_field(Field *field);
  table_map used_tables() const;
  enum Item_result result_type () const;
  Item_result cast_to_int_type() const;
  enum_field_types field_type() const;
  int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
  Field *get_tmp_table_field() { return result_field; }
  Field *tmp_table_field(Table *) { return result_field; }
  bool get_date(type::Time &ltime,uint32_t fuzzydate);
  bool get_date_result(type::Time &ltime, uint32_t fuzzydate);
  bool get_time(type::Time &ltime);
  bool is_null();
  void update_null_value();
  Item *get_tmp_table_item(Session *session);
  bool collect_item_field_processor(unsigned char * arg);
  bool find_item_in_field_list_processor(unsigned char *arg);
  bool register_field_in_read_map(unsigned char *arg);
  void cleanup();
  bool result_as_int64_t();
  Item_equal *find_item_equal(COND_EQUAL *cond_equal);
  bool subst_argument_checker(unsigned char **arg);
  Item *equal_fields_propagator(unsigned char *arg);
  bool set_no_const_sub(unsigned char *arg);
  Item *replace_equal_field(unsigned char *arg);
  uint32_t max_disp_length();
  Item *safe_charset_converter(const charset_info_st * const tocs);
  int fix_outer_field(Session *session, Field **field, Item **reference);
  virtual Item *update_value_transformer(unsigned char *select_arg);
  virtual void print(String *str);

  friend class Item_default_value;
  friend class Item_insert_value;
  friend class Select_Lex_Unit;
};

}
# 24 "./drizzled/item/cache.h" 2


# 1 "./drizzled/util/test.h" 1
# 21 "./drizzled/util/test.h"
       

namespace drizzled {

template <class T>
bool test(const T a)
{
  return bool(a);
}

template <class T, class U>
bool test_all_bits(const T a, const U b)
{
  return (a & b) == b;
}

}
# 27 "./drizzled/item/cache.h" 2

namespace drizzled {

class Item_cache : public Item_basic_constant
{
protected:
  Item *example;
  table_map used_table_map;






  Field *cached_field;
  enum enum_field_types cached_field_type;
public:
  Item_cache():
    example(0), used_table_map(0), cached_field(0), cached_field_type(DRIZZLE_TYPE_VARCHAR)
  {
    fixed= 1;
    null_value= 1;
  }
  Item_cache(enum_field_types field_type_arg):
    example(0), used_table_map(0), cached_field(0), cached_field_type(field_type_arg)
  {
    fixed= 1;
    null_value= 1;
  }

  void set_used_tables(table_map map) { used_table_map= map; }

  virtual void allocate(uint32_t) {};
  virtual bool setup(Item *item)
  {
    example= item;
    max_length= item->max_length;
    decimals= item->decimals;
    collation.set(item->collation);
    unsigned_flag= item->unsigned_flag;
    if (item->type() == FIELD_ITEM)
      cached_field= ((Item_field *)item)->field;
    return 0;
  };
  virtual void store(Item *)= 0;
  enum Type type() const { return CACHE_ITEM; }
  enum_field_types field_type() const { return cached_field_type; }
  static Item_cache* get_cache(const Item *item);
  table_map used_tables() const { return used_table_map; }
  virtual void keep_array() {}
  virtual void print(String *str);
  bool eq_def(Field *field);
  bool eq(const Item *item, bool) const
  {
    return this == item;
  }
  bool basic_const_item() const
  {
    return test(example && example->basic_const_item());
  }
};

}
# 23 "./drizzled/item/cache_int.h" 2

namespace drizzled {

class Item_cache_int : public Item_cache
{
public:
  Item_cache_int(): Item_cache(), value(0) {}
  Item_cache_int(enum_field_types field_type_arg):
    Item_cache(field_type_arg), value(0) {}

  void store(Item *item);
  void store(Item *item, int64_t val_arg);
  double val_real() { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/cache_int.h", 35, __PRETTY_FUNCTION__)); return (double) value; }
  int64_t val_int() { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/cache_int.h", 36, __PRETTY_FUNCTION__)); return value; }
  String* val_str(String *str);
  type::Decimal *val_decimal(type::Decimal *);
  enum Item_result result_type() const { return INT_RESULT; }
  bool result_as_int64_t() { return true; }
protected:
  int64_t value;
};

}
# 32 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/item/cmpfunc.h" 1
# 20 "./drizzled/item/cmpfunc.h"
       




# 1 "./drizzled/comp_creator.h" 1
# 20 "./drizzled/comp_creator.h"
       



namespace drizzled {

class Comp_creator
{
public:
  virtual ~Comp_creator() {}
  virtual Item_bool_func2* create(Item *a, Item *b) const = 0;
  virtual const char* symbol(bool invert) const = 0;
  virtual bool eqne_op() const = 0;
  virtual bool l_op() const = 0;
};

typedef Comp_creator* (*chooser_compare_func_creator)(bool invert);

Comp_creator *comp_eq_creator(bool invert);
Comp_creator *comp_ge_creator(bool invert);
Comp_creator *comp_gt_creator(bool invert);
Comp_creator *comp_le_creator(bool invert);
Comp_creator *comp_lt_creator(bool invert);
Comp_creator *comp_ne_creator(bool invert);

}
# 26 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/function/math/int.h" 1
# 20 "./drizzled/function/math/int.h"
       

# 1 "./drizzled/function/func.h" 1
# 22 "./drizzled/function/func.h"
       





# 1 "./drizzled/item/bin_string.h" 1
# 20 "./drizzled/item/bin_string.h"
       


# 1 "./drizzled/item/hex_string.h" 1
# 20 "./drizzled/item/hex_string.h"
       



namespace drizzled {

class Item_hex_string : public Item_basic_constant
{
public:
  Item_hex_string() {}
  Item_hex_string(str_ref);
  Type type() const { return VARBIN_ITEM; }
  double val_real()
  {
    ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/hex_string.h", 34, __PRETTY_FUNCTION__));
    return (double) (uint64_t) Item_hex_string::val_int();
  }
  int64_t val_int();
  bool basic_const_item() const { return 1; }
  String *val_str(String*) { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/hex_string.h", 39, __PRETTY_FUNCTION__)); return &str_value; }
  type::Decimal *val_decimal(type::Decimal *);
  int save_in_field(Field *field, bool no_conversions);
  enum Item_result result_type () const { return STRING_RESULT; }
  enum Item_result cast_to_int_type() const { return INT_RESULT; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_VARCHAR; }
  virtual void print(String *str);
  bool eq(const Item *item, bool binary_cmp) const;
  virtual Item *safe_charset_converter(const charset_info_st * const tocs);
};

}
# 24 "./drizzled/item/bin_string.h" 2


namespace drizzled {

class Item_bin_string : public Item_hex_string
{
public:
  Item_bin_string(str_ref);
};

class __attribute__ ((visibility("default"))) Item_result_field : public Item
{
public:
  Field *result_field;
  Item_result_field() : result_field(0) {}

  Item_result_field(Session *session, Item_result_field *item):
    Item(session, item), result_field(item->result_field)
  {}
  Field *get_tmp_table_field() { return result_field; }
  Field *tmp_table_field(Table *)
  { return result_field; }
  table_map used_tables() const { return 1; }
  virtual void fix_length_and_dec()=0;
  void set_result_field(Field *field) { result_field= field; }
  bool is_result_field() { return true; }
  void save_in_result_field(bool no_conversions)
  {
    save_in_field(result_field, no_conversions);
  }
  void cleanup();
};

}
# 29 "./drizzled/function/func.h" 2
# 1 "./drizzled/lex_string.h" 1
# 20 "./drizzled/lex_string.h"
       

# 1 "/usr/include/c++/4.8/cstddef" 1 3
# 39 "/usr/include/c++/4.8/cstddef" 3
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 23 "./drizzled/lex_string.h" 2


namespace drizzled {






struct lex_string_t
{
  const char* begin() const
  {
    return data();
  }

  const char* end() const
  {
    return data() + size();
  }

  const char* data() const
  {
    return str_;
  }

  size_t size() const
  {
    return length_;
  }

  void assign(const char* d, size_t s)
  {
    str_= const_cast<char*>(d);
    length_ = s;
  }

  void operator=(str_ref v)
  {
    assign(v.data(), v.size());
  }

  char* str_;
  size_t length_;
};

inline const lex_string_t &null_lex_string()
{
  static lex_string_t tmp= { __null, 0 };
  return tmp;
}

struct execute_string_t : public lex_string_t
{
private:
  bool is_variable;
public:

  bool isVariable() const
  {
    return is_variable;
  }

  void set(const lex_string_t& s, bool is_variable_arg= false)
  {
    is_variable= is_variable_arg;
    static_cast<lex_string_t&>(*this) = s;
  }

};




}
# 30 "./drizzled/function/func.h" 2





namespace drizzled {

class __attribute__ ((visibility("default"))) Item_func : public Item_result_field
{
protected:
  Item **args, *tmp_arg[2];




  uint32_t allowed_arg_cols;

public:

  using Item::split_sum_func;

  uint32_t arg_count;
  table_map used_tables_cache, not_null_tables_cache;
  bool const_item_cache;
  enum Functype { UNKNOWN_FUNC,EQ_FUNC,EQUAL_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,
                  GE_FUNC,GT_FUNC,
                  LIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
                  COND_AND_FUNC, COND_OR_FUNC, COND_XOR_FUNC,
                  BETWEEN, IN_FUNC, MULT_EQUAL_FUNC,
                  INTERVAL_FUNC, ISNOTNULLTEST_FUNC,
                  NOT_FUNC, NOT_ALL_FUNC,
                  NOW_FUNC, TRIG_COND_FUNC,
                  SUSERVAR_FUNC, GUSERVAR_FUNC, COLLATE_FUNC,
                  EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP,
                  NEG_FUNC };
  enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL,
                       OPTIMIZE_EQUAL };
  enum Type type() const { return FUNC_ITEM; }
  virtual enum Functype functype() const { return UNKNOWN_FUNC; }
  virtual ~Item_func() {}

  Item_func(void);

  Item_func(Item *a);

  Item_func(Item *a,Item *b);

  Item_func(Item *a,Item *b,Item *c);

  Item_func(Item *a,Item *b,Item *c,Item *d);

  Item_func(Item *a,Item *b,Item *c,Item *d,Item* e);

  Item_func(List<Item> &list);


  Item_func(Session *session, Item_func *item);

  bool fix_fields(Session *, Item **ref);
  void fix_after_pullout(Select_Lex *new_parent, Item **ref);
  table_map used_tables() const;
  table_map not_null_tables() const;
  void update_used_tables();
  bool eq(const Item *item, bool binary_cmp) const;
  virtual optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  virtual bool have_rev_func() const { return 0; }
  virtual Item *key_item() const { return args[0]; }
# 107 "./drizzled/function/func.h"
  virtual const char *func_name() const { return __null; }
  virtual bool const_item() const { return const_item_cache; }
  Item **arguments() const { return args; }
  void set_arguments(List<Item> &list);
  uint32_t argument_count() const { return arg_count; }
  void remove_arguments() { arg_count=0; }





  virtual bool check_argument_count(int) { return true ; }
  virtual void split_sum_func(Session *session, Item **ref_pointer_array,
                              List<Item> &fields);

  virtual void print(String *str);
  void print_op(String *str);
  void print_args(String *str, uint32_t from);
  virtual void fix_num_length_and_dec();
  void count_only_length();
  void count_real_length();
  void count_decimal_length();

  bool get_arg0_date(type::Time &ltime, uint32_t fuzzy_date);
  bool get_arg0_time(type::Time &ltime);

  bool is_null();

  virtual bool deterministic() const
  {
    return false;
  }

  void signal_divide_by_null();

  virtual Field *tmp_table_field() { return result_field; }
  virtual Field *tmp_table_field(Table *t_arg);

  Item *get_tmp_table_item(Session *session);

  type::Decimal *val_decimal(type::Decimal *);

  bool agg_arg_collations(DTCollation &c, Item **items, uint32_t nitems,
                          uint32_t flags);
  bool agg_arg_collations_for_comparison(DTCollation &c,
                                         Item **items, uint32_t nitems,
                                         uint32_t flags);
  bool agg_arg_charsets(DTCollation &c, Item **items, uint32_t nitems,
                        uint32_t flags, int item_sep);
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);
  Item *transform(Item_transformer transformer, unsigned char *arg);
  Item* compile(Item_analyzer analyzer, unsigned char **arg_p,
                Item_transformer transformer, unsigned char *arg_t);
  void traverse_cond(Cond_traverser traverser,
                     void * arg, traverse_order order);
  double fix_result(double value);
};

}
# 23 "./drizzled/function/math/int.h" 2


namespace drizzled
{

class __attribute__ ((visibility("default"))) Item_int_func :
  public Item_func
{
public:
  Item_int_func() :Item_func() { max_length= 21; }
  Item_int_func(Item *a) :Item_func(a) { max_length= 21; }
  Item_int_func(Item *a,Item *b) :Item_func(a,b) { max_length= 21; }
  Item_int_func(Item *a,Item *b,Item *c) :Item_func(a,b,c)
  { max_length= 21; }
  Item_int_func(List<Item> &list) :Item_func(list) { max_length= 21; }
  Item_int_func(Session *session, Item_int_func *item) :Item_func(session, item) {}
  virtual ~Item_int_func();
  double val_real();
  String *val_str(String*str);
  enum Item_result result_type () const { return INT_RESULT; }
  void fix_length_and_dec() {}
};

}
# 27 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/function/numhybrid.h" 1
# 20 "./drizzled/function/numhybrid.h"
       



namespace drizzled
{

class Item_func_numhybrid: public Item_func
{
protected:
  Item_result hybrid_type;
public:
  Item_func_numhybrid(): Item_func(), hybrid_type(REAL_RESULT)
  {}
  Item_func_numhybrid(Item *a) :Item_func(a), hybrid_type(REAL_RESULT)
  {}
  Item_func_numhybrid(Item *a,Item *b)
    :Item_func(a,b), hybrid_type(REAL_RESULT)
  {}
  Item_func_numhybrid(List<Item> &list)
    :Item_func(list), hybrid_type(REAL_RESULT)
  {}

  enum Item_result result_type () const { return hybrid_type; }
  void fix_length_and_dec();
  void fix_num_length_and_dec();
  virtual void find_num_type()= 0;

  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  String *val_str(String*str);







  virtual int64_t int_op()= 0;







  virtual double real_op()= 0;
# 79 "./drizzled/function/numhybrid.h"
  virtual type::Decimal *decimal_op(type::Decimal *)= 0;







  virtual String *str_op(String *)= 0;
  bool is_null() { update_null_value(); return null_value; }
};

}
# 28 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/decimal.h" 1
# 20 "./drizzled/item/decimal.h"
       

# 1 "./drizzled/item/num.h" 1
# 20 "./drizzled/item/num.h"
       




namespace drizzled {

class Item_num : public Item_basic_constant
{
public:
  virtual Item_num *neg()= 0;
  Item *safe_charset_converter(const charset_info_st*);
};

}
# 23 "./drizzled/item/decimal.h" 2

namespace drizzled {


class Item_decimal : public Item_num
{
protected:
  type::Decimal decimal_value;
public:
  Item_decimal(const char *str_arg, uint32_t length, const charset_info_st*);
  Item_decimal(const char *str, const type::Decimal *val_arg, uint32_t decimal_par, uint32_t length);
  Item_decimal(type::Decimal *value_par);
  Item_decimal(int64_t val, bool unsig);
  Item_decimal(double val, int precision, int scale);
  Item_decimal(const unsigned char *bin, int precision, int scale);

  enum Type type() const { return DECIMAL_ITEM; }
  enum Item_result result_type () const { return DECIMAL_RESULT; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_DECIMAL; }
  int64_t val_int();
  double val_real();
  String *val_str(String*);
  type::Decimal *val_decimal(type::Decimal *)
  { return &decimal_value; }
  int save_in_field(Field *field, bool no_conversions);
  bool basic_const_item() const { return true; }
  Item *clone_item()
  {
    return new Item_decimal(name, &decimal_value, decimals, max_length);
  }
  virtual void print(String *str);
  Item_num *neg()
  {
    class_decimal_neg(&decimal_value);
    unsigned_flag= !decimal_value.sign();
    return this;
  }
  uint32_t decimal_precision() const { return decimal_value.precision(); }
  bool eq(const Item *, bool binary_cmp) const;
  void set_decimal_value(type::Decimal *value_par);
};

}
# 29 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/float.h" 1
# 20 "./drizzled/item/float.h"
       



namespace drizzled {

class Item_float : public Item_num
{
  const char *presentation;
public:
  double value;
  Item_float(const char *str_arg, uint32_t length);
  Item_float(const char *str,double val_arg,uint32_t decimal_par,uint32_t length)
    :value(val_arg)
  {
    presentation= name= str;
    decimals=(uint8_t) decimal_par;
    max_length=length;
    fixed= 1;
  }
  Item_float(double value_par, uint32_t decimal_par) :presentation(0), value(value_par)
  {
    decimals= (uint8_t) decimal_par;
    fixed= 1;
  }
  int save_in_field(Field *field, bool no_conversions);
  enum Type type() const { return REAL_ITEM; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE; }
  double val_real() { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/float.h", 48, __PRETTY_FUNCTION__)); return value; }
  int64_t val_int();
  String *val_str(String*);
  type::Decimal *val_decimal(type::Decimal *);
  bool basic_const_item() const { return 1; }
  Item *clone_item()
  { return new Item_float(name, value, decimals, max_length); }
  Item_num *neg() { value= -value; return this; }
  virtual void print(String *str);
  bool eq(const Item *, bool binary_cmp) const;
};

class Item_static_float_func :public Item_float
{
  const char *func_name;
public:
  Item_static_float_func(const char *str, double val_arg, uint32_t decimal_par,
                        uint32_t length)
    :Item_float(__null, val_arg, decimal_par, length), func_name(str)
  {}

  virtual inline void print(String *str)
  {
    str->append(func_name, strlen(func_name));
  }

  Item *safe_charset_converter(const charset_info_st * const tocs);
};

}
# 30 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/function/boolean.h" 1
# 23 "./drizzled/item/function/boolean.h"
       



namespace drizzled
{

namespace item
{

namespace function
{

class Boolean :public Item_int_func
{
public:
  Boolean() :
    Item_int_func()
  {}

  Boolean(Item *a) :
    Item_int_func(a)
  {}

  Boolean(Item *a,Item *b) :
    Item_int_func(a,b)
  {}

  Boolean(Session *session, Boolean *item) :
    Item_int_func(session, item)
  {}

  bool is_bool_func()
  {
    return true;
  }

  void fix_length_and_dec()
  {
    decimals= 0;
    max_length= 1;
  }

  uint32_t decimal_precision() const
  {
    return 1;
  }
};

}
}
}
# 31 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/int.h" 1
# 20 "./drizzled/item/int.h"
       




namespace drizzled {

class Item_int : public Item_num
{
public:
  int64_t value;

  Item_int(int32_t i,uint32_t length= 11) :
    value((int64_t) i)
    { max_length=length; fixed= 1; }

  Item_int(int64_t i,uint32_t length= 21) :
    value(i)
    { max_length=length; fixed= 1; }

  Item_int(uint64_t i, uint32_t length= 21) :
    value((int64_t)i)
  { max_length=length; fixed=1; }

  Item_int(const char *str_arg,int64_t i,uint32_t length) :
    value(i)
    { max_length= length; name= const_cast<char *>(str_arg); fixed= 1; }

  Item_int(const char *str_arg, uint32_t length=64);

  enum Type type() const { return INT_ITEM; }

  enum Item_result result_type () const { return INT_RESULT; }

  enum_field_types field_type() const { return DRIZZLE_TYPE_LONGLONG; }

  int64_t val_int() { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/int.h", 56, __PRETTY_FUNCTION__)); return value; }

  double val_real() { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/int.h", 58, __PRETTY_FUNCTION__)); return (double) value; }

  type::Decimal *val_decimal(type::Decimal *);

  String *val_str(String*);

  int save_in_field(Field *field, bool no_conversions);

  bool basic_const_item() const { return 1; }

  Item *clone_item() { return new Item_int(name,value,max_length); }

  virtual void print(String *str);

  Item_num *neg() { value= -value; return this; }

  uint32_t decimal_precision() const
  { return (uint32_t)(max_length - test(value < 0)); }

  bool eq(const Item *, bool binary_cmp) const;
};

}
# 32 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/row.h" 1
# 20 "./drizzled/item/row.h"
       



namespace drizzled {

class Item_row : public Item
{
  Item **items;
  table_map used_tables_cache;
  uint32_t arg_count;
  bool const_item_cache;
  bool with_null;
public:

  using Item::split_sum_func;

  Item_row(List<Item> &);
  Item_row(Item_row *item):
    Item(),
    items(item->items),
    used_tables_cache(item->used_tables_cache),
    arg_count(item->arg_count),
    const_item_cache(item->const_item_cache),
    with_null(0)
  {}

  enum Type type() const { return ROW_ITEM; };
  void illegal_method_call(const char*);
  bool is_null() { return null_value; }
  void make_field(SendField *)
  {
    illegal_method_call("make_field");
  };
  double val_real()
  {
    illegal_method_call("val");
    return 0;
  };
  int64_t val_int()
  {
    illegal_method_call("val_int");
    return 0;
  };
  String *val_str(String *)
  {
    illegal_method_call("val_str");
    return 0;
  };
  type::Decimal *val_decimal(type::Decimal *)
  {
    illegal_method_call("val_decimal");
    return 0;
  };
  bool fix_fields(Session *session, Item **ref);
  void fix_after_pullout(Select_Lex *new_parent, Item **ref);
  void cleanup();
  void split_sum_func(Session *session, Item **ref_pointer_array, List<Item> &fields);
  table_map used_tables() const { return used_tables_cache; };
  bool const_item() const { return const_item_cache; };
  enum Item_result result_type() const { return ROW_RESULT; }
  void update_used_tables();
  virtual void print(String *str);

  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);
  Item *transform(Item_transformer transformer, unsigned char *arg);

  uint32_t cols() { return arg_count; }
  Item* element_index(uint32_t i) { return items[i]; }
  Item** addr(uint32_t i) { return items + i; }
  bool check_cols(uint32_t c);
  bool null_inside() { return with_null; };
  void bring_value();
};

}
# 33 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/string.h" 1
# 20 "./drizzled/item/string.h"
       




namespace drizzled {

class Item_string : public Item_basic_constant
{
public:
  Item_string(str_ref str, const charset_info_st* cs, Derivation dv= DERIVATION_COERCIBLE)
  {
    ((not (str.size() % cs->mbminlen)) ? static_cast<void> (0) : __assert_fail ("not (str.size() % cs->mbminlen)", "./drizzled/item/string.h", 32, __PRETTY_FUNCTION__));
    str_value.set(str.data(), str.size(), cs);
    collation.set(cs, dv);







    max_length= str_value.numchars() * cs->mbmaxlen;
    set_name(str.data(), str.size(), cs);
    decimals=(uint8_t)31;

    fixed= 1;
  }

  Item_string(const char *str,uint32_t length,
              const charset_info_st * const cs, Derivation dv= DERIVATION_COERCIBLE)
  {
    ((not (length % cs->mbminlen)) ? static_cast<void> (0) : __assert_fail ("not (length % cs->mbminlen)", "./drizzled/item/string.h", 52, __PRETTY_FUNCTION__));
    str_value.set(str, length, cs);
    collation.set(cs, dv);







    max_length= str_value.numchars()*cs->mbmaxlen;
    set_name(str, length, cs);
    decimals=(uint8_t)31;

    fixed= 1;
  }

  Item_string(const charset_info_st * const cs, Derivation dv= DERIVATION_COERCIBLE)
  {
    collation.set(cs, dv);
    max_length= 0;
    set_name(__null, 0, cs);
    decimals= (uint8_t)31;
    fixed= 1;
  }
  Item_string(const char *name_par, const char *str, uint32_t length,
              const charset_info_st * const cs, Derivation dv= DERIVATION_COERCIBLE)
  {
    ((not (length % cs->mbminlen)) ? static_cast<void> (0) : __assert_fail ("not (length % cs->mbminlen)", "./drizzled/item/string.h", 80, __PRETTY_FUNCTION__));
    str_value.set(str, length, cs);
    collation.set(cs, dv);
    max_length= str_value.numchars()*cs->mbmaxlen;
    set_name(name_par, 0, cs);
    decimals=(uint8_t)31;

    fixed= 1;
  }
  enum Type type() const { return STRING_ITEM; }
  double val_real();
  int64_t val_int();
  String *val_str(String*)
  {
    ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/string.h", 94, __PRETTY_FUNCTION__));
    return (String*) &str_value;
  }
  type::Decimal *val_decimal(type::Decimal *);
  int save_in_field(Field *field, bool no_conversions);
  enum Item_result result_type () const { return STRING_RESULT; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_VARCHAR; }
  bool basic_const_item() const { return 1; }
  bool eq(const Item *item, bool binary_cmp) const;
  Item *clone_item()
  {
    return new Item_string(name, str_value.ptr(), str_value.length(), collation.collation);
  }
  Item *safe_charset_converter(const charset_info_st * const tocs);
  inline void append(str_ref v)
  {
    str_value.append(v);
    max_length= str_value.numchars() * collation.collation->mbmaxlen;
  }
  virtual void print(String *str);
};


class Item_static_string_func : public Item_string
{
  const char *func_name;
public:
  Item_static_string_func(const char *name_par,
                          str_ref str,
                          const charset_info_st* cs,
                          Derivation dv= DERIVATION_COERCIBLE) :
    Item_string(__null, str.data(), str.size(), cs, dv),
    func_name(name_par)
  {}
  Item *safe_charset_converter(const charset_info_st*);

  virtual inline void print(String *str)
  {
    str->append(func_name, strlen(func_name));
  }
};

}
# 34 "./drizzled/item/cmpfunc.h" 2
# 1 "./drizzled/item/sum.h" 1
# 20 "./drizzled/item/sum.h"
       



# 1 "./drizzled/tree.h" 1
# 16 "./drizzled/tree.h"
       



# 1 "./drizzled/base.h" 1
# 30 "./drizzled/base.h"
       

namespace drizzled
{
# 65 "./drizzled/base.h"
enum ha_rkey_function {
  HA_READ_KEY_EXACT,
  HA_READ_KEY_OR_NEXT,
  HA_READ_KEY_OR_PREV,
  HA_READ_AFTER_KEY,
  HA_READ_BEFORE_KEY,
  HA_READ_PREFIX,
  HA_READ_PREFIX_LAST,
  HA_READ_PREFIX_LAST_OR_PREV,
  HA_READ_MBR_CONTAIN,
  HA_READ_MBR_INTERSECT,
  HA_READ_MBR_WITHIN,
  HA_READ_MBR_DISJOINT,
  HA_READ_MBR_EQUAL
};



enum ha_key_alg {
  HA_KEY_ALG_UNDEF= 0,
  HA_KEY_ALG_BTREE= 1,
  HA_KEY_ALG_HASH= 3
};



enum ha_extra_function {
  HA_EXTRA_NORMAL=0,
  HA_EXTRA_QUICK=1,
  HA_EXTRA_NOT_USED=2,
  HA_EXTRA_CACHE=3,
  HA_EXTRA_NO_CACHE=4,
  HA_EXTRA_NO_READCHECK=5,
  HA_EXTRA_READCHECK=6,
  HA_EXTRA_KEYREAD=7,
  HA_EXTRA_NO_KEYREAD=8,
  HA_EXTRA_NO_USER_CHANGE=9,
  HA_EXTRA_KEY_CACHE=10,
  HA_EXTRA_NO_KEY_CACHE=11,
  HA_EXTRA_WAIT_LOCK=12,
  HA_EXTRA_NO_WAIT_LOCK=13,
  HA_EXTRA_WRITE_CACHE=14,
  HA_EXTRA_FLUSH_CACHE=15,
  HA_EXTRA_NO_KEYS=16,
  HA_EXTRA_KEYREAD_CHANGE_POS=17,

  HA_EXTRA_REMEMBER_POS=18,
  HA_EXTRA_RESTORE_POS=19,
  HA_EXTRA_REINIT_CACHE=20,
  HA_EXTRA_FORCE_REOPEN=21,
  HA_EXTRA_FLUSH,
  HA_EXTRA_NO_ROWS,
  HA_EXTRA_RESET_STATE,
  HA_EXTRA_IGNORE_DUP_KEY,
  HA_EXTRA_NO_IGNORE_DUP_KEY,
  HA_EXTRA_PREPARE_FOR_DROP,
  HA_EXTRA_PREPARE_FOR_UPDATE,
  HA_EXTRA_PRELOAD_BUFFER_SIZE,



  HA_EXTRA_CHANGE_KEY_TO_UNIQUE,
  HA_EXTRA_CHANGE_KEY_TO_DUP,





  HA_EXTRA_KEYREAD_PRESERVE_FIELDS,







  HA_EXTRA_IGNORE_NO_KEY,
  HA_EXTRA_NO_IGNORE_NO_KEY,







  HA_EXTRA_WRITE_CAN_REPLACE,
  HA_EXTRA_WRITE_CANNOT_REPLACE,






  HA_EXTRA_DELETE_CANNOT_BATCH,
  HA_EXTRA_UPDATE_CANNOT_BATCH,




  HA_EXTRA_INSERT_WITH_UPDATE,

  HA_EXTRA_PREPARE_FOR_RENAME
};



enum ha_panic_function {
  HA_PANIC_CLOSE,
  HA_PANIC_WRITE,
  HA_PANIC_READ
};



enum ha_base_keytype {
  HA_KEYTYPE_END=0,
  HA_KEYTYPE_TEXT=1,
  HA_KEYTYPE_BINARY=2,
  HA_KEYTYPE_LONG_INT=4,
  HA_KEYTYPE_DOUBLE=6,
  HA_KEYTYPE_ULONG_INT=9,
  HA_KEYTYPE_LONGLONG=10,
  HA_KEYTYPE_ULONGLONG=11,

  HA_KEYTYPE_VARTEXT1=15,
  HA_KEYTYPE_VARBINARY1=16,

  HA_KEYTYPE_VARTEXT2=17,
  HA_KEYTYPE_VARBINARY2=18
};
# 304 "./drizzled/base.h"
typedef unsigned long key_part_map;
# 348 "./drizzled/base.h"
enum en_fieldtype {
  FIELD_LAST=-1,FIELD_NORMAL,FIELD_SKIP_ENDSPACE,FIELD_SKIP_PRESPACE,
  FIELD_SKIP_ZERO,FIELD_BLOB,FIELD_CONSTANT,FIELD_INTERVALL,FIELD_ZERO,
  FIELD_VARCHAR,FIELD_CHECK,
  FIELD_enum_val_count
};

enum data_file_type {
  STATIC_RECORD, DYNAMIC_RECORD, COMPRESSED_RECORD, BLOCK_RECORD
};
# 392 "./drizzled/base.h"
class key_range
{
public:
  const unsigned char *key;
  uint32_t length;
  enum ha_rkey_function flag;
  key_part_map keypart_map;
};

class KEY_MULTI_RANGE
{
public:
  key_range start_key;
  key_range end_key;
  char *ptr;
  uint32_t range_flag;
};



typedef uint64_t ha_rows;
# 423 "./drizzled/base.h"
inline static uint32_t ha_varchar_packlength(uint32_t field_length)
{
  return (field_length < 256 ? 1 :2);
}


}
# 21 "./drizzled/tree.h" 2



namespace drizzled
{


static const int MAX_TREE_HEIGHT= 64;

static const int TREE_NO_DUPS= 1;

typedef enum { left_root_right, right_root_left } TREE_WALK;
typedef int (*tree_walk_action)(void *,uint32_t,void *);

typedef enum { free_init, free_free, free_end } TREE_FREE;
typedef void (*tree_element_free)(void*, TREE_FREE, void *);


class Tree_Element
{
public:
 Tree_Element *left,*right;
 uint32_t count:31,
     colour:1;
};

static const int TREE_ELEMENT_EXTRA_SIZE= (sizeof(Tree_Element) + sizeof(void*));






class Tree
{
private:
 Tree_Element *root, null_element;
 void *custom_arg;
 Tree_Element **parents[MAX_TREE_HEIGHT];
 uint32_t offset_to_key, elements_in_tree, size_of_element;
 size_t memory_limit;
 size_t allocated;
 qsort_cmp2 compare;
 memory::Root mem_root;
 bool with_delete;
 tree_element_free free;
 uint32_t flag;

public:
 void* getCustomArg() {
  return custom_arg;
 }
 Tree_Element* getRoot() {
  return root;
 }
 void setRoot(Tree_Element* root_arg) {
  root = root_arg;
 }
 uint32_t getElementsInTree() {
  return elements_in_tree;
 }

 void init_tree(size_t default_alloc_size, uint32_t memory_limit,
       uint32_t size, qsort_cmp2 compare, bool with_delete,
       tree_element_free free_element, void *custom_arg);
 bool is_inited()
 {
  return this->root != 0;
 }
 void delete_tree();
 void reset_tree();


 Tree_Element *tree_insert(void *key, uint32_t key_size, void *custom_arg);
 int tree_walk(tree_walk_action action, void *argument, TREE_WALK visit);

private:
 void free_tree(myf free_flags);

 void* element_key(Tree_Element* element);
 void delete_tree_element(Tree_Element* element);
 int tree_walk_left_root_right(Tree_Element* element, tree_walk_action action, void* argument);
 int tree_walk_right_root_left(Tree_Element* element, tree_walk_action action, void* argument);

 void left_rotate(Tree_Element **parent,Tree_Element *element);
 void right_rotate(Tree_Element **parent, Tree_Element *element);
 void rb_insert(Tree_Element ***parent, Tree_Element *element);
};

}
# 25 "./drizzled/item/sum.h" 2
# 1 "./drizzled/hybrid_type.h" 1
# 20 "./drizzled/hybrid_type.h"
       



namespace drizzled {
# 33 "./drizzled/hybrid_type.h"
class Hybrid_type
{
public:
  int64_t integer;

  double real;






  type::Decimal dec_buf[3];
  int used_dec_buf_no;






  const Hybrid_type_traits *traits;

  Hybrid_type() {}

  Hybrid_type(const Hybrid_type &rhs) :traits(rhs.traits) {}
};

}
# 26 "./drizzled/item/sum.h" 2





namespace drizzled {

int group_concat_key_cmp_with_distinct(void* arg, const void* key1, const void* key2);

int group_concat_key_cmp_with_order(void* arg, const void* key1, const void* key2);
# 232 "./drizzled/item/sum.h"
class Item_sum :public Item_result_field
{
public:
  enum Sumfunctype
  { COUNT_FUNC, COUNT_DISTINCT_FUNC, SUM_FUNC, SUM_DISTINCT_FUNC, AVG_FUNC,
    AVG_DISTINCT_FUNC, MIN_FUNC, MAX_FUNC, STD_FUNC,
    VARIANCE_FUNC, SUM_BIT_FUNC, GROUP_CONCAT_FUNC
  };

  Item **args, *tmp_args[2];
  Item **ref_by;
  Item_sum *next;
  uint32_t arg_count;
  Item_sum *in_sum_func;
  Select_Lex * aggr_sel;
  int8_t nest_level;
  int8_t aggr_level;
  int8_t max_arg_level;
  int8_t max_sum_func_level;
  bool quick_group;






  List<Item_field> outer_fields;

protected:
  table_map used_tables_cache;
  bool forced_const;

public:

  void mark_as_sum_func();
  Item_sum() :arg_count(0), quick_group(1), forced_const(false)
  {
    mark_as_sum_func();
  }
  Item_sum(Item *a) :args(tmp_args), arg_count(1), quick_group(1),
    forced_const(false)
  {
    args[0]=a;
    mark_as_sum_func();
  }
  Item_sum( Item *a, Item *b ) :args(tmp_args), arg_count(2), quick_group(1),
    forced_const(false)
  {
    args[0]=a; args[1]=b;
    mark_as_sum_func();
  }
  Item_sum(List<Item> &list);

  Item_sum(Session *session, Item_sum *item);
  enum Type type() const { return SUM_FUNC_ITEM; }
  virtual enum Sumfunctype sum_func () const=0;






  inline bool reset() { clear(); return add(); };







  virtual void clear()= 0;







  virtual bool add()=0;
# 321 "./drizzled/item/sum.h"
  virtual void reset_field()=0;





  virtual void update_field()=0;
  virtual bool keep_field_type(void) const { return 0; }
  virtual void fix_length_and_dec() { maybe_null=1; null_value=1; }
# 345 "./drizzled/item/sum.h"
  virtual const char *func_name() const= 0;
  virtual Item *result_item(Field *field)
    { return new Item_field(field); }
  table_map used_tables() const { return used_tables_cache; }
  void update_used_tables ();
  void cleanup()
  {
    Item::cleanup();
    forced_const= false;
  }
  bool is_null() { return null_value; }
  void make_const ()
  {
    used_tables_cache= 0;
    forced_const= true;
  }
  virtual bool const_item() const { return forced_const; }
  virtual bool const_during_execution() const { return false; }
  void make_field(SendField *field);
  virtual void print(String *str);
  void fix_num_length_and_dec();
# 375 "./drizzled/item/sum.h"
  void no_rows_in_result() { clear(); }

  virtual bool setup(Session *) {return 0;}
  virtual void make_unique(void) {}
  Item *get_tmp_table_item(Session *session);
  virtual Field *create_tmp_field(bool group, Table *table,
                                  uint32_t convert_blob_length);
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *argument);
  bool init_sum_func_check(Session *session);
  bool check_sum_func(Session *session, Item **ref);
  bool register_sum_func(Session *session, Item **ref);
  Select_Lex *depended_from()
    { return (nest_level == aggr_level ? 0 : aggr_sel); }
};


class Item_sum_num :public Item_sum
{
protected:






  bool is_evaluated;
public:
  Item_sum_num() :Item_sum(),is_evaluated(false) {}
  Item_sum_num(Item *item_par)
    :Item_sum(item_par), is_evaluated(false) {}
  Item_sum_num(Item *a, Item* b) :Item_sum(a,b),is_evaluated(false) {}
  Item_sum_num(List<Item> &list)
    :Item_sum(list), is_evaluated(false) {}
  Item_sum_num(Session *session, Item_sum_num *item)
    :Item_sum(session, item),is_evaluated(item->is_evaluated) {}
  bool fix_fields(Session *, Item **);
  int64_t val_int();
  String *val_str(String*str);
  type::Decimal *val_decimal(type::Decimal *);
  void reset_field();
};


class Item_sum_int :public Item_sum_num
{
public:
  Item_sum_int(Item *item_par) :Item_sum_num(item_par) {}
  Item_sum_int(List<Item> &list) :Item_sum_num(list) {}
  Item_sum_int(Session *session, Item_sum_int *item) :Item_sum_num(session, item) {}
  double val_real() { ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "./drizzled/item/sum.h", 424, __PRETTY_FUNCTION__)); return (double) val_int(); }
  String *val_str(String*str);
  type::Decimal *val_decimal(type::Decimal *);
  enum Item_result result_type () const { return INT_RESULT; }
  void fix_length_and_dec()
  { decimals=0; max_length=21; maybe_null=null_value=0; }
};


class Item_sum_sum :public Item_sum_num
{
protected:
  Item_result hybrid_type;
  double sum;
  type::Decimal dec_buffs[2];
  uint32_t curr_dec_buff;
  void fix_length_and_dec();

public:
  Item_sum_sum(Item *item_par) :Item_sum_num(item_par) {}
  Item_sum_sum(Session *session, Item_sum_sum *item);
  enum Sumfunctype sum_func () const {return SUM_FUNC;}
  void clear();
  bool add();
  double val_real();
  int64_t val_int();
  String *val_str(String*str);
  type::Decimal *val_decimal(type::Decimal *);
  enum Item_result result_type () const { return hybrid_type; }
  void reset_field();
  void update_field();
  void no_rows_in_result() {}
  const char *func_name() const { return "sum("; }
  Item *copy_or_same(Session* session);
};





class Item_sum_distinct :public Item_sum_num
{
protected:

  uint64_t count;
  Hybrid_type val;

  Unique *tree;
  Table *table;
  enum enum_field_types table_field_type;
  uint32_t tree_key_length;
protected:
  Item_sum_distinct(Session *session, Item_sum_distinct *item);
public:
  Item_sum_distinct(Item *item_par);
  ~Item_sum_distinct();

  bool setup(Session *session);
  void clear();
  void cleanup();
  bool add();
  double val_real();
  type::Decimal *val_decimal(type::Decimal *);
  int64_t val_int();
  String *val_str(String *str);



  enum Sumfunctype sum_func () const { return SUM_DISTINCT_FUNC; }
  void reset_field() {}
  void update_field() {}
  virtual void no_rows_in_result() {}
  void fix_length_and_dec();
  enum Item_result result_type () const;
  virtual void calculate_val_and_count();
  virtual bool unique_walk_function(void *elem);
};
# 509 "./drizzled/item/sum.h"
class Item_sum_sum_distinct :public Item_sum_distinct
{
private:
  Item_sum_sum_distinct(Session *session, Item_sum_sum_distinct *item)
    :Item_sum_distinct(session, item) {}
public:
  Item_sum_sum_distinct(Item *item_arg) :Item_sum_distinct(item_arg) {}

  enum Sumfunctype sum_func () const { return SUM_DISTINCT_FUNC; }
  const char *func_name() const { return "sum(distinct "; }
  Item *copy_or_same(Session* session) { return new Item_sum_sum_distinct(session, this); }
};




class Item_sum_avg_distinct: public Item_sum_distinct
{
private:
  Item_sum_avg_distinct(Session *session, Item_sum_avg_distinct *original)
    :Item_sum_distinct(session, original) {}
public:
  uint32_t prec_increment;
  Item_sum_avg_distinct(Item *item_arg) : Item_sum_distinct(item_arg) {}

  void fix_length_and_dec();
  virtual void calculate_val_and_count();
  enum Sumfunctype sum_func () const { return AVG_DISTINCT_FUNC; }
  const char *func_name() const { return "avg(distinct "; }
  Item *copy_or_same(Session* session) { return new Item_sum_avg_distinct(session, this); }
};


class Item_sum_count :public Item_sum_int
{
  int64_t count;

  public:
  Item_sum_count(Item *item_par)
    :Item_sum_int(item_par),count(0)
  {}
  Item_sum_count(Session *session, Item_sum_count *item)
    :Item_sum_int(session, item), count(item->count)
  {}
  enum Sumfunctype sum_func () const { return COUNT_FUNC; }
  void clear();
  void no_rows_in_result() { count=0; }
  bool add();
  void make_const_count(int64_t count_arg)
  {
    count=count_arg;
    Item_sum::make_const();
  }
  int64_t val_int();
  void reset_field();
  void cleanup();
  void update_field();
  const char *func_name() const { return "count("; }
  Item *copy_or_same(Session* session);
};


class Item_sum_count_distinct :public Item_sum_int
{
  Table *table;
  uint32_t *field_lengths;
  Tmp_Table_Param *tmp_table_param;
  bool force_copy_fields;





  Unique *tree;





  int64_t count;




  Item_sum_count_distinct *original;
  uint32_t tree_key_length;


  bool always_null;


  friend int composite_key_cmp(void* arg, unsigned char* key1, unsigned char* key2);
  friend int simple_str_key_cmp(void* arg, unsigned char* key1, unsigned char* key2);

public:
  Item_sum_count_distinct(List<Item> &list)
    :Item_sum_int(list), table(0), field_lengths(0), tmp_table_param(0),
     force_copy_fields(0), tree(0), count(0),
     original(0), always_null(false)
  { quick_group= 0; }
  Item_sum_count_distinct(Session *session, Item_sum_count_distinct *item)
    :Item_sum_int(session, item), table(item->table),
     field_lengths(item->field_lengths),
     tmp_table_param(item->tmp_table_param),
     force_copy_fields(0), tree(item->tree), count(item->count),
     original(item), tree_key_length(item->tree_key_length),
     always_null(item->always_null)
  {}
  ~Item_sum_count_distinct();

  void cleanup();

  enum Sumfunctype sum_func () const { return COUNT_DISTINCT_FUNC; }
  void clear();
  bool add();
  int64_t val_int();
  void reset_field() { return ;}
  void update_field() { return ; }
  const char *func_name() const { return "count(distinct "; }
  bool setup(Session *session);
  void make_unique();
  Item *copy_or_same(Session* session);
  void no_rows_in_result() {}
};




class Item_avg_field :public Item_result_field
{
public:
  Field *field;
  Item_result hybrid_type;
  uint32_t f_precision, f_scale, dec_bin_size;
  uint32_t prec_increment;
  Item_avg_field(Item_result res_type, Item_sum_avg *item);
  enum Type type() const { return FIELD_AVG_ITEM; }
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  bool is_null() { update_null_value(); return null_value; }
  String *val_str(String*);
  enum_field_types field_type() const
  {
    return hybrid_type == DECIMAL_RESULT ?
      DRIZZLE_TYPE_DECIMAL : DRIZZLE_TYPE_DOUBLE;
  }
  void fix_length_and_dec() {}
  enum Item_result result_type () const { return hybrid_type; }
};


class Item_sum_avg :public Item_sum_sum
{
public:
  uint64_t count;
  uint32_t prec_increment;
  uint32_t f_precision, f_scale, dec_bin_size;

  Item_sum_avg(Item *item_par) :Item_sum_sum(item_par), count(0) {}
  Item_sum_avg(Session *session, Item_sum_avg *item)
    :Item_sum_sum(session, item), count(item->count),
    prec_increment(item->prec_increment) {}

  void fix_length_and_dec();
  enum Sumfunctype sum_func () const {return AVG_FUNC;}
  void clear();
  bool add();
  double val_real();

  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  String *val_str(String *str);
  void reset_field();
  void update_field();
  Item *result_item(Field *)
  { return new Item_avg_field(hybrid_type, this); }
  void no_rows_in_result() {}
  const char *func_name() const { return "avg("; }
  Item *copy_or_same(Session* session);
  Field *create_tmp_field(bool group, Table *table, uint32_t convert_blob_length);
  void cleanup()
  {
    count= 0;
    Item_sum_sum::cleanup();
  }
};

class Item_variance_field :public Item_result_field
{
public:
  Field *field;
  Item_result hybrid_type;
  uint32_t f_precision0, f_scale0;
  uint32_t f_precision1, f_scale1;
  uint32_t dec_bin_size0, dec_bin_size1;
  uint32_t sample;
  uint32_t prec_increment;
  Item_variance_field(Item_sum_variance *item);
  enum Type type() const {return FIELD_VARIANCE_ITEM; }
  double val_real();
  int64_t val_int();
  String *val_str(String *str)
  { return val_string_from_real(str); }
  type::Decimal *val_decimal(type::Decimal *dec_buf)
  { return val_decimal_from_real(dec_buf); }
  bool is_null() { update_null_value(); return null_value; }
  enum_field_types field_type() const
  {
    return hybrid_type == DECIMAL_RESULT ?
      DRIZZLE_TYPE_DECIMAL : DRIZZLE_TYPE_DOUBLE;
  }
  void fix_length_and_dec() {}
  enum Item_result result_type () const { return hybrid_type; }
};
# 746 "./drizzled/item/sum.h"
class Item_sum_variance : public Item_sum_num
{
  void fix_length_and_dec();

public:
  Item_result hybrid_type;
  int cur_dec;
  double recurrence_m, recurrence_s;
  uint64_t count;
  uint32_t f_precision0, f_scale0;
  uint32_t f_precision1, f_scale1;
  uint32_t dec_bin_size0, dec_bin_size1;
  uint32_t sample;
  uint32_t prec_increment;

  Item_sum_variance(Item *item_par, uint32_t sample_arg) :Item_sum_num(item_par),
    hybrid_type(REAL_RESULT), count(0), sample(sample_arg)
    {}
  Item_sum_variance(Session *session, Item_sum_variance *item);
  enum Sumfunctype sum_func () const { return VARIANCE_FUNC; }
  void clear();
  bool add();
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  void reset_field();
  void update_field();
  Item *result_item(Field *)
  { return new Item_variance_field(this); }
  void no_rows_in_result() {}
  const char *func_name() const
    { return sample ? "var_samp(" : "variance("; }
  Item *copy_or_same(Session* session);
  Field *create_tmp_field(bool group, Table *table, uint32_t convert_blob_length);
  enum Item_result result_type () const { return REAL_RESULT; }
  void cleanup()
  {
    count= 0;
    Item_sum_num::cleanup();
  }
};

class Item_std_field :public Item_variance_field
{
public:
  Item_std_field(Item_sum_std *item);
  enum Type type() const { return FIELD_STD_ITEM; }
  double val_real();
  type::Decimal *val_decimal(type::Decimal *);
  enum Item_result result_type () const { return REAL_RESULT; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE;}
};





class Item_sum_std :public Item_sum_variance
{
  public:
  Item_sum_std(Item *item_par, uint32_t sample_arg)
    :Item_sum_variance(item_par, sample_arg) {}
  Item_sum_std(Session *session, Item_sum_std *item)
    :Item_sum_variance(session, item)
    {}
  enum Sumfunctype sum_func () const { return STD_FUNC; }
  double val_real();
  Item *result_item(Field *)
    { return new Item_std_field(this); }
  const char *func_name() const { return "std("; }
  Item *copy_or_same(Session* session);
  enum Item_result result_type () const { return REAL_RESULT; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_DOUBLE;}
};



class Item_sum_hybrid :public Item_sum
{
protected:
  String value,tmp_value;
  double sum;
  int64_t sum_int;
  type::Decimal sum_dec;
  Item_result hybrid_type;
  enum_field_types hybrid_field_type;
  int cmp_sign;
  bool was_values;

  public:
  Item_sum_hybrid(Item *item_par,int sign)
    :Item_sum(item_par), sum(0.0), sum_int(0),
    hybrid_type(INT_RESULT), hybrid_field_type(DRIZZLE_TYPE_LONGLONG),
    cmp_sign(sign), was_values(true)
  { collation.set(&my_charset_bin); }
  Item_sum_hybrid(Session *session, Item_sum_hybrid *item);
  bool fix_fields(Session *, Item **);
  void clear();
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  void reset_field();
  String *val_str(String *);
  bool keep_field_type(void) const { return 1; }
  enum Item_result result_type () const { return hybrid_type; }
  enum enum_field_types field_type() const { return hybrid_field_type; }
  void update_field();
  void min_max_update_str_field();
  void min_max_update_real_field();
  void min_max_update_int_field();
  void min_max_update_decimal_field();
  void cleanup();
  bool any_value() { return was_values; }
  void no_rows_in_result();
  Field *create_tmp_field(bool group, Table *table,
     uint32_t convert_blob_length);
};


class Item_sum_min :public Item_sum_hybrid
{
public:
  Item_sum_min(Item *item_par) :Item_sum_hybrid(item_par,1) {}
  Item_sum_min(Session *session, Item_sum_min *item) :Item_sum_hybrid(session, item) {}
  enum Sumfunctype sum_func () const {return MIN_FUNC;}

  bool add();
  const char *func_name() const { return "min("; }
  Item *copy_or_same(Session* session);
};


class Item_sum_max :public Item_sum_hybrid
{
public:
  Item_sum_max(Item *item_par) :Item_sum_hybrid(item_par,-1) {}
  Item_sum_max(Session *session, Item_sum_max *item) :Item_sum_hybrid(session, item) {}
  enum Sumfunctype sum_func () const {return MAX_FUNC;}

  bool add();
  const char *func_name() const { return "max("; }
  Item *copy_or_same(Session* session);
};


class Item_sum_bit :public Item_sum_int
{
protected:
  uint64_t reset_bits,bits;

public:
  Item_sum_bit(Item *item_par,uint64_t reset_arg)
    :Item_sum_int(item_par),reset_bits(reset_arg),bits(reset_arg) {}
  Item_sum_bit(Session *session, Item_sum_bit *item):
    Item_sum_int(session, item), reset_bits(item->reset_bits), bits(item->bits) {}
  enum Sumfunctype sum_func () const {return SUM_BIT_FUNC;}
  void clear();
  int64_t val_int();
  void reset_field();
  void update_field();
  void fix_length_and_dec()
  { decimals= 0; max_length=21; unsigned_flag= 1; maybe_null= null_value= 0; }
  void cleanup()
  {
    bits= reset_bits;
    Item_sum_int::cleanup();
  }
};


class Item_sum_or :public Item_sum_bit
{
public:
  Item_sum_or(Item *item_par) :Item_sum_bit(item_par,0) {}
  Item_sum_or(Session *session, Item_sum_or *item) :Item_sum_bit(session, item) {}
  bool add();
  const char *func_name() const { return "bit_or("; }
  Item *copy_or_same(Session* session);
};


class Item_sum_and :public Item_sum_bit
{
  public:
  Item_sum_and(Item *item_par) :Item_sum_bit(item_par, (18446744073709551615ULL)) {}
  Item_sum_and(Session *session, Item_sum_and *item) :Item_sum_bit(session, item) {}
  bool add();
  const char *func_name() const { return "bit_and("; }
  Item *copy_or_same(Session* session);
};

class Item_sum_xor :public Item_sum_bit
{
  public:
  Item_sum_xor(Item *item_par) :Item_sum_bit(item_par,0) {}
  Item_sum_xor(Session *session, Item_sum_xor *item) :Item_sum_bit(session, item) {}
  bool add();
  const char *func_name() const { return "bit_xor("; }
  Item *copy_or_same(Session* session);
};

class Item_func_group_concat : public Item_sum
{
  Tmp_Table_Param *tmp_table_param;
  DRIZZLE_ERROR *warning;
  String result;
  String *separator;
  Tree tree_base;
  Tree *tree;
# 963 "./drizzled/item/sum.h"
  Unique *unique_filter;
  Table *table;
  Order **order;
  Name_resolution_context *context;

  uint32_t arg_count_order;

  uint32_t arg_count_field;
  uint32_t count_cut_values;
  bool distinct;
  bool warning_for_row;
  bool always_null;
  bool force_copy_fields;
  bool no_appended;




  Item_func_group_concat *original;

  friend int group_concat_key_cmp_with_distinct(void* arg, const void* key1,
                                                const void* key2);
  friend int group_concat_key_cmp_with_order(void* arg, const void* key1,
          const void* key2);
  friend int dump_leaf_key(unsigned char* key, uint32_t,
                           Item_func_group_concat *group_concat_item);

public:
  Item_func_group_concat(Name_resolution_context *context_arg,
                         bool is_distinct, List<Item> *is_select,
                         SQL_LIST *is_order, String *is_separator);

  Item_func_group_concat(Session *session, Item_func_group_concat *item);
  ~Item_func_group_concat();
  void cleanup();

  enum Sumfunctype sum_func () const {return GROUP_CONCAT_FUNC;}
  const char *func_name() const { return "group_concat"; }
  virtual Item_result result_type () const { return STRING_RESULT; }
  enum_field_types field_type() const
  {
    if (max_length/collation.collation->mbmaxlen > 512 )
      return DRIZZLE_TYPE_BLOB;
    else
      return DRIZZLE_TYPE_VARCHAR;
  }
  void clear();
  bool add();
  void reset_field() { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/item/sum.h", 1011, __PRETTY_FUNCTION__)); }
  void update_field() { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/item/sum.h", 1012, __PRETTY_FUNCTION__)); }
  bool fix_fields(Session *,Item **);
  bool setup(Session *session);
  void make_unique();
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *decimal_value)
  {
    return val_decimal_from_string(decimal_value);
  }
  String* val_str(String* str);
  Item *copy_or_same(Session* session);
  void no_rows_in_result() {}
  virtual void print(String *str);
  virtual bool change_context_processor(unsigned char *cntx)
    { context= (Name_resolution_context *)cntx; return false; }
};

}
# 35 "./drizzled/item/cmpfunc.h" 2


namespace drizzled {

extern Item_result item_cmp_type(Item_result a,Item_result b);

typedef int (Arg_comparator::*arg_cmp_func)();

typedef int (*Item_field_cmpfunc)(Item_field *f1, Item_field *f2, void *arg);

int64_t get_datetime_value(Session *session,
                           Item ***item_arg,
                           Item **cache_arg,
                           Item *warn_item,
                           bool *is_null);

class Arg_comparator: public memory::SqlAlloc
{
  Item **a, **b;
  arg_cmp_func func;
  Item_bool_func2 *owner;
  Arg_comparator *comparators;
  double precision;

  Session *session;
  enum_field_types a_type, b_type;
  Item *a_cache, *b_cache;
  bool is_nulls_eq;
  enum enum_date_cmp_type { CMP_DATE_DFLT= 0, CMP_DATE_WITH_DATE,
                            CMP_DATE_WITH_STR, CMP_STR_WITH_DATE };
  int64_t (*get_value_func)(Session *session, Item ***item_arg, Item **cache_arg,
                            Item *warn_item, bool *is_null);
public:
  DTCollation cmp_collation;

  Arg_comparator();

  Arg_comparator(Item **a1, Item **a2);

  int set_compare_func(Item_bool_func2 *owner, Item_result type);
  inline int set_compare_func(Item_bool_func2 *owner_arg)
  {
    return set_compare_func(owner_arg, item_cmp_type((*a)->result_type(),
                                                     (*b)->result_type()));
  }
  int set_cmp_func(Item_bool_func2 *owner_arg,
     Item **a1, Item **a2,
     Item_result type);

  inline int set_cmp_func(Item_bool_func2 *owner_arg,
     Item **a1, Item **a2)
  {
    return set_cmp_func(owner_arg, a1, a2,
                        item_cmp_type((*a1)->result_type(),
                                      (*a2)->result_type()));
  }
  inline int compare() { return (this->*func)(); }

  int compare_string();
  int compare_binary_string();
  int compare_real();
  int compare_decimal();
  int compare_int_signed();
  int compare_int_signed_unsigned();
  int compare_int_unsigned_signed();
  int compare_int_unsigned();
  int compare_row();
  int compare_e_string();
  int compare_e_binary_string();
  int compare_e_real();
  int compare_e_decimal();
  int compare_e_int();
  int compare_e_int_diff_signedness();
  int compare_e_row();
  int compare_real_fixed();
  int compare_e_real_fixed();
  int compare_datetime();

  static enum enum_date_cmp_type can_compare_as_dates(Item *a, Item *b,
                                                      int64_t *const_val_arg);

  void set_datetime_cmp_func(Item **a1, Item **b1);
  static arg_cmp_func comparator_matrix [5][2];

  friend class Item_func;
};







class Item_func_truth : public item::function::Boolean
{
public:
  virtual bool val_bool();
  virtual int64_t val_int();
  virtual void fix_length_and_dec();
  virtual void print(String *str);

protected:
  Item_func_truth(Item *a, bool a_value, bool a_affirmative)
  : item::function::Boolean(a), value(a_value), affirmative(a_affirmative)
  {}

private:




  const bool value;



  const bool affirmative;
};






class Item_func_istrue : public Item_func_truth
{
public:
  Item_func_istrue(Item *a) : Item_func_truth(a, true, true) {}
  virtual const char* func_name() const { return "istrue"; }
};






class Item_func_isnottrue : public Item_func_truth
{
public:
  Item_func_isnottrue(Item *a) : Item_func_truth(a, true, false) {}
  virtual const char* func_name() const { return "isnottrue"; }
};






class Item_func_isfalse : public Item_func_truth
{
public:
  Item_func_isfalse(Item *a) : Item_func_truth(a, false, true) {}
  virtual const char* func_name() const { return "isfalse"; }
};






class Item_func_isnotfalse : public Item_func_truth
{
public:
  Item_func_isnotfalse(Item *a) : Item_func_truth(a, false, false) {}
  virtual const char* func_name() const { return "isnotfalse"; }
};
# 220 "./drizzled/item/cmpfunc.h"
class Item_in_optimizer: public item::function::Boolean
{
protected:
  Item_cache *cache;
  bool save_cache;






  bool result_for_null_param;
public:
  Item_in_optimizer(Item *a, Item_in_subselect *b):
    item::function::Boolean(a, reinterpret_cast<Item *>(b)), cache(0),
    save_cache(0), result_for_null_param(((bool)-1))
  { with_subselect= true; }
  bool fix_fields(Session *, Item **);
  bool fix_left(Session *session, Item **ref);
  bool is_null();
  int64_t val_int();
  void cleanup();
  const char *func_name() const { return "<in_optimizer>"; }
  Item_cache **get_cache() { return &cache; }
  void keep_top_level_cache();
  Item *transform(Item_transformer transformer, unsigned char *arg);
};

class Eq_creator :public Comp_creator
{
public:
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "<>" : "="; }
  virtual bool eqne_op() const { return 1; }
  virtual bool l_op() const { return 0; }
  static const Eq_creator *instance();
};

class Ne_creator :public Comp_creator
{
public:
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "=" : "<>"; }
  virtual bool eqne_op() const { return 1; }
  virtual bool l_op() const { return 0; }
  static const Ne_creator *instance();
};

class Gt_creator :public Comp_creator
{
public:
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "<=" : ">"; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 0; }
  static const Gt_creator *instance();
};

class Lt_creator :public Comp_creator
{
public:
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? ">=" : "<"; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 1; }
  static const Lt_creator *instance();
};

class Ge_creator :public Comp_creator
{
public:
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? "<" : ">="; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 0; }
  static const Ge_creator *instance();
};

class Le_creator :public Comp_creator
{
public:
  virtual Item_bool_func2* create(Item *a, Item *b) const;
  virtual const char* symbol(bool invert) const { return invert? ">" : "<="; }
  virtual bool eqne_op() const { return 0; }
  virtual bool l_op() const { return 1; }
  static const Le_creator *instance();
};

class Item_bool_func2 :public Item_int_func
{
protected:
  Arg_comparator cmp;
  String tmp_value1,tmp_value2;
  bool abort_on_null;

public:
  Item_bool_func2(Item *a,Item *b)
    :Item_int_func(a,b), cmp(tmp_arg, tmp_arg+1), abort_on_null(false) {}
  void fix_length_and_dec();
  void set_cmp_func()
  {
    cmp.set_cmp_func(this, tmp_arg, tmp_arg+1);
  }
  optimize_type select_optimize() const { return OPTIMIZE_OP; }
  virtual enum Functype rev_functype() const { return UNKNOWN_FUNC; }
  bool have_rev_func() const { return rev_functype() != UNKNOWN_FUNC; }

  virtual inline void print(String *str)
  {
    Item_func::print_op(str);
  }

  bool is_null() { return test(args[0]->is_null() || args[1]->is_null()); }
  bool is_bool_func() { return 1; }
  const charset_info_st *compare_collation() { return cmp.cmp_collation.collation; }
  uint32_t decimal_precision() const { return 1; }
  void top_level_item() { abort_on_null= true; }

  friend class Arg_comparator;
};

class Item_bool_rowready_func2 :public Item_bool_func2
{
public:
  Item_bool_rowready_func2(Item *a, Item *b) :Item_bool_func2(a, b)
  {
    allowed_arg_cols= 0;
  }
  Item *neg_transformer(Session *session);
  virtual Item *negated_item();
  bool subst_argument_checker(unsigned char **)
  { return true; }
};

class Item_func_not :public item::function::Boolean
{
public:
  Item_func_not(Item *a) :item::function::Boolean(a) {}
  int64_t val_int();
  enum Functype functype() const { return NOT_FUNC; }
  const char *func_name() const { return "not"; }
  Item *neg_transformer(Session *session);
  virtual void print(String *str);
};
# 394 "./drizzled/item/cmpfunc.h"
class Item_func_trig_cond: public item::function::Boolean
{
  bool *trig_var;
public:
  Item_func_trig_cond(Item *a, bool *f) : item::function::Boolean(a) { trig_var= f; }
  int64_t val_int() { return *trig_var ? args[0]->val_int() : 1; }
  enum Functype functype() const { return TRIG_COND_FUNC; };
  const char *func_name() const { return "trigcond"; };
  bool const_item() const { return false; }
  bool *get_trig_var() { return trig_var; }

  table_map used_tables() const { return args[0]->used_tables(); }
};

class Item_func_not_all :public Item_func_not
{

  Item_sum_hybrid *test_sum_item;
  Item_maxmin_subselect *test_sub_item;

  bool abort_on_null;
public:
  bool show;

  Item_func_not_all(Item *a)
    :Item_func_not(a), test_sum_item(0), test_sub_item(0), abort_on_null(0),
     show(0)
    {}
  virtual void top_level_item() { abort_on_null= 1; }
  bool top_level() { return abort_on_null; }
  int64_t val_int();
  enum Functype functype() const { return NOT_ALL_FUNC; }
  const char *func_name() const { return "<not>"; }
  virtual void print(String *str);
  void set_sum_test(Item_sum_hybrid *item) { test_sum_item= item; };
  void set_sub_test(Item_maxmin_subselect *item) { test_sub_item= item; };
  bool empty_underlying_subquery();
  Item *neg_transformer(Session *session);
};


class Item_func_nop_all :public Item_func_not_all
{
public:

  Item_func_nop_all(Item *a) :Item_func_not_all(a) {}
  int64_t val_int();
  const char *func_name() const { return "<nop>"; }
  Item *neg_transformer(Session *session);
};


class Item_func_eq :public Item_bool_rowready_func2
{
public:
  Item_func_eq(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
  int64_t val_int();
  enum Functype functype() const { return EQ_FUNC; }
  enum Functype rev_functype() const { return EQ_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "="; }
  Item *negated_item();
};

class Item_func_equal :public Item_bool_rowready_func2
{
public:
  Item_func_equal(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
  int64_t val_int();
  void fix_length_and_dec();
  table_map not_null_tables() const { return 0; }
  enum Functype functype() const { return EQUAL_FUNC; }
  enum Functype rev_functype() const { return EQUAL_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "<=>"; }
  Item *neg_transformer(Session *) { return 0; }
};


class Item_func_ge :public Item_bool_rowready_func2
{
public:
  Item_func_ge(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
  int64_t val_int();
  enum Functype functype() const { return GE_FUNC; }
  enum Functype rev_functype() const { return LE_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return ">="; }
  Item *negated_item();
};


class Item_func_gt :public Item_bool_rowready_func2
{
public:
  Item_func_gt(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
  int64_t val_int();
  enum Functype functype() const { return GT_FUNC; }
  enum Functype rev_functype() const { return LT_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  const char *func_name() const { return ">"; }
  Item *negated_item();
};


class Item_func_le :public Item_bool_rowready_func2
{
public:
  Item_func_le(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {};
  int64_t val_int();
  enum Functype functype() const { return LE_FUNC; }
  enum Functype rev_functype() const { return GE_FUNC; }
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "<="; }
  Item *negated_item();
};


class Item_func_lt :public Item_bool_rowready_func2
{
public:
  Item_func_lt(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
  int64_t val_int();
  enum Functype functype() const { return LT_FUNC; }
  enum Functype rev_functype() const { return GT_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  const char *func_name() const { return "<"; }
  Item *negated_item();
};


class Item_func_ne :public Item_bool_rowready_func2
{
public:
  Item_func_ne(Item *a,Item *b) :Item_bool_rowready_func2(a,b) {}
  int64_t val_int();
  enum Functype functype() const { return NE_FUNC; }
  cond_result eq_cmp_result() const { return COND_FALSE; }
  optimize_type select_optimize() const { return OPTIMIZE_KEY; }
  const char *func_name() const { return "<>"; }
  Item *negated_item();
};
# 547 "./drizzled/item/cmpfunc.h"
class Item_func_opt_neg :public Item_int_func
{
public:
  bool negated;
  bool pred_level;
public:
  Item_func_opt_neg(Item *a, Item *b, Item *c)
    :Item_int_func(a, b, c), negated(0), pred_level(0) {}
  Item_func_opt_neg(List<Item> &list)
    :Item_int_func(list), negated(0), pred_level(0) {}
public:
  inline void negate() { negated= !negated; }
  inline void top_level_item() { pred_level= 1; }
  Item *neg_transformer(Session *)
  {
    negated= !negated;
    return this;
  }
  bool eq(const Item *item, bool binary_cmp) const;
  bool subst_argument_checker(unsigned char **)
  { return true; }
};


class Item_func_between :public Item_func_opt_neg
{
  DTCollation cmp_collation;
public:
  Item_result cmp_type;
  String value0,value1,value2;

  bool compare_as_dates;

  Arg_comparator ge_cmp, le_cmp;
  Item_func_between(Item *a, Item *b, Item *c)
    :Item_func_opt_neg(a, b, c), compare_as_dates(false) {}
  int64_t val_int();
  optimize_type select_optimize() const { return OPTIMIZE_KEY; }
  enum Functype functype() const { return BETWEEN; }
  const char *func_name() const { return "between"; }
  bool fix_fields(Session *, Item **);
  void fix_length_and_dec();
  virtual void print(String *str);
  bool is_bool_func() { return 1; }
  const charset_info_st *compare_collation() { return cmp_collation.collation; }
  uint32_t decimal_precision() const { return 1; }
};


class Item_func_strcmp :public Item_bool_func2
{
public:
  Item_func_strcmp(Item *a,Item *b) :Item_bool_func2(a,b) {}
  int64_t val_int();
  optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  const char *func_name() const { return "strcmp"; }

  virtual inline void print(String *str)
  {
    Item_func::print(str);
  }
};


struct interval_range
{
  Item_result type;
  double dbl;
  type::Decimal dec;
};

class Item_func_interval :public Item_int_func
{
  Item_row *row;
  bool use_decimal_comparison;
  interval_range *intervals;
public:
  Item_func_interval(Item_row *a)
    :Item_int_func(a),row(a),intervals(0)
  {
    allowed_arg_cols= 0;
  }
  int64_t val_int();
  void fix_length_and_dec();
  const char *func_name() const { return "interval"; }
  uint32_t decimal_precision() const { return 2; }
};


class Item_func_coalesce :public Item_func_numhybrid
{
protected:
  enum_field_types cached_field_type;
  Item_func_coalesce(Item *a, Item *b) :Item_func_numhybrid(a, b) {}
public:
  Item_func_coalesce(List<Item> &list) :Item_func_numhybrid(list) {}
  double real_op();
  int64_t int_op();
  String *str_op(String *);
  type::Decimal *decimal_op(type::Decimal *);
  void fix_length_and_dec();
  void find_num_type() {}
  enum Item_result result_type () const { return hybrid_type; }
  const char *func_name() const { return "coalesce"; }
  table_map not_null_tables() const { return 0; }
  enum_field_types field_type() const { return cached_field_type; }
};


class Item_func_ifnull :public Item_func_coalesce
{
protected:
  bool field_type_defined;
public:
  Item_func_ifnull(Item *a, Item *b) :Item_func_coalesce(a,b) {}
  double real_op();
  int64_t int_op();
  String *str_op(String *str);
  type::Decimal *decimal_op(type::Decimal *);
  enum_field_types field_type() const;
  void fix_length_and_dec();
  const char *func_name() const { return "ifnull"; }
  Field *tmp_table_field()
  {
    return Item_func::tmp_table_field();
  }
  Field *tmp_table_field(Table *table);
  uint32_t decimal_precision() const;
};


class Item_func_if :public Item_func
{
  Item_result cached_result_type;
  enum_field_types cached_field_type;

public:
  Item_func_if(Item *a, Item *b, Item *c) :
    Item_func(a,b,c),
    cached_result_type(INT_RESULT)
  {}

  double val_real();
  int64_t val_int();
  String *val_str(String *str);
  type::Decimal *val_decimal(type::Decimal *);
  Item_result result_type () const { return cached_result_type; }
  enum_field_types field_type() const { return cached_field_type; }
  bool fix_fields(Session *, Item **);
  void fix_length_and_dec();
  uint32_t decimal_precision() const;
  const char *func_name() const { return "if"; }
};


class Item_func_nullif :public Item_bool_func2
{
  enum Item_result cached_result_type;
public:
  Item_func_nullif(Item *a,Item *b)
    :Item_bool_func2(a,b), cached_result_type(INT_RESULT)
  {}
  double val_real();
  int64_t val_int();
  String *val_str(String *str);
  type::Decimal *val_decimal(type::Decimal *);
  enum Item_result result_type () const { return cached_result_type; }
  void fix_length_and_dec();
  uint32_t decimal_precision() const { return args[0]->decimal_precision(); }
  const char *func_name() const { return "nullif"; }

  virtual inline void print(String *str)
  {
    Item_func::print(str);
  }

  table_map not_null_tables() const { return 0; }
  bool is_null();
};







class in_vector :public memory::SqlAlloc
{
public:
  char *base;
  uint32_t size;
  qsort2_cmp compare;
  const charset_info_st *collation;
  uint32_t count;
  uint32_t used_count;
  in_vector() {}
  in_vector(uint32_t elements,uint32_t element_length,qsort2_cmp cmp_func,
       const charset_info_st * const cmp_coll)
    :base((char*) memory::sql_calloc(elements*element_length)),
     size(element_length), compare(cmp_func), collation(cmp_coll),
     count(elements), used_count(elements) {}
  virtual ~in_vector() {}
  virtual void set(uint32_t pos,Item *item)=0;
  virtual unsigned char *get_value(Item *item)=0;
  void sort();
  int find(Item *item);
# 762 "./drizzled/item/cmpfunc.h"
  virtual Item* create_item() { return __null; }
# 772 "./drizzled/item/cmpfunc.h"
  virtual void value_to_item(uint32_t, Item *) { }


  bool compare_elems(uint32_t pos1, uint32_t pos2)
  {
    return test(compare(collation, base + pos1*size, base + pos2*size));
  }
  virtual Item_result result_type()= 0;
};

class in_string :public in_vector
{
  char buff[80];
  String tmp;
public:
  in_string(uint32_t elements,qsort2_cmp cmp_func, const charset_info_st * const cs);
  ~in_string();
  void set(uint32_t pos,Item *item);
  unsigned char *get_value(Item *item);
  Item* create_item()
  {
    return new Item_string(collation);
  }
  void value_to_item(uint32_t pos, Item *item)
  {
    String *str=((String*) base)+pos;
    Item_string *to= (Item_string*)item;
    to->str_value= *str;
  }
  Item_result result_type() { return STRING_RESULT; }
};

class in_int64_t :public in_vector
{
protected:





  struct packed_int64_t
  {
    int64_t val;
    int64_t unsigned_flag;
  } tmp;
public:
  in_int64_t(uint32_t elements);
  void set(uint32_t pos,Item *item);
  unsigned char *get_value(Item *item);

  Item* create_item()
  {




    return new Item_int((int64_t)0);
  }
  void value_to_item(uint32_t pos, Item *item)
  {
    ((Item_int*) item)->value= ((packed_int64_t*) base)[pos].val;
    ((Item_int*) item)->unsigned_flag= (bool)
      ((packed_int64_t*) base)[pos].unsigned_flag;
  }
  Item_result result_type() { return INT_RESULT; }

  friend int cmp_int64_t(void *cmp_arg, packed_int64_t *a,packed_int64_t *b);
};
# 848 "./drizzled/item/cmpfunc.h"
class in_datetime :public in_int64_t
{
public:
  Session *session;

  Item *warn_item;

  Item *lval_cache;

  in_datetime(Item *warn_item_arg, uint32_t elements);

  void set(uint32_t pos,Item *item);
  unsigned char *get_value(Item *item);
  friend int cmp_int64_t(void *cmp_arg, packed_int64_t *a,packed_int64_t *b);
};


class in_double :public in_vector
{
  double tmp;
public:
  in_double(uint32_t elements);
  void set(uint32_t pos,Item *item);
  unsigned char *get_value(Item *item);
  Item *create_item()
  {
    return new Item_float(0.0, 0);
  }
  void value_to_item(uint32_t pos, Item *item)
  {
    ((Item_float*)item)->value= ((double*) base)[pos];
  }
  Item_result result_type() { return REAL_RESULT; }
};


class in_decimal :public in_vector
{
  type::Decimal val;
public:
  in_decimal(uint32_t elements);
  void set(uint32_t pos, Item *item);
  unsigned char *get_value(Item *item);
  Item *create_item()
  {
    return new Item_decimal(0, false);
  }
  void value_to_item(uint32_t pos, Item *item)
  {
    type::Decimal *dec= ((type::Decimal *)base) + pos;
    Item_decimal *item_dec= (Item_decimal*)item;
    item_dec->set_decimal_value(dec);
  }
  Item_result result_type() { return DECIMAL_RESULT; }

};






class cmp_item :public memory::SqlAlloc
{
public:
  const charset_info_st *cmp_charset;

  cmp_item()
  {
    cmp_charset= &my_charset_bin;
  }

  virtual ~cmp_item() {}
  virtual void store_value(Item *item)= 0;
  virtual int cmp(Item *item)= 0;

  virtual int compare(cmp_item *item)= 0;
  static cmp_item* get_comparator(Item_result type, const charset_info_st * const cs);
  virtual cmp_item *make_same()= 0;
  virtual void store_value_by_template(cmp_item *, Item *item)
  {
    store_value(item);
  }
};

class cmp_item_string :public cmp_item
{
protected:
  String *value_res;
public:
  cmp_item_string () {}
  cmp_item_string (const charset_info_st * const cs) { cmp_charset= cs; }
  void set_charset(const charset_info_st * const cs) { cmp_charset= cs; }
  friend class cmp_item_sort_string;
  friend class cmp_item_sort_string_in_static;
};

class cmp_item_sort_string :public cmp_item_string
{
protected:
  char value_buff[80];
  String value;
public:
  cmp_item_sort_string():
    cmp_item_string() {}
  cmp_item_sort_string(const charset_info_st * const cs):
    cmp_item_string(cs),
    value(value_buff, sizeof(value_buff), cs) {}
  void store_value(Item *item)
  {
    value_res= item->val_str(&value);
  }
  int cmp(Item *arg)
  {
    char buff[80];
    String tmp(buff, sizeof(buff), cmp_charset), *res;
    res= arg->val_str(&tmp);
    return (value_res ? (res ? sortcmp(value_res, res, cmp_charset) : 1) :
            (res ? -1 : 0));
  }
  int compare(cmp_item *ci)
  {
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
  }
  cmp_item *make_same();
  void set_charset(const charset_info_st * const cs)
  {
    cmp_charset= cs;
    value.set_quick(value_buff, sizeof(value_buff), cs);
  }
};

class cmp_item_int :public cmp_item
{
  int64_t value;
public:
  void store_value(Item *item)
  {
    value= item->val_int();
  }
  int cmp(Item *arg)
  {
    return value != arg->val_int();
  }
  int compare(cmp_item *ci)
  {
    cmp_item_int *l_cmp= (cmp_item_int *)ci;
    return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
  }
  cmp_item *make_same();
};







class cmp_item_datetime :public cmp_item
{
  int64_t value;

public:
  Session *session;

  Item *warn_item;

  Item *lval_cache;

  cmp_item_datetime(Item *warn_item_arg);

  void store_value(Item *item);
  int cmp(Item *arg);
  int compare(cmp_item *ci);
  cmp_item *make_same();
};

class cmp_item_real :public cmp_item
{
  double value;
public:
  void store_value(Item *item)
  {
    value= item->val_real();
  }
  int cmp(Item *arg)
  {
    return value != arg->val_real();
  }
  int compare(cmp_item *ci)
  {
    cmp_item_real *l_cmp= (cmp_item_real *) ci;
    return (value < l_cmp->value)? -1 : ((value == l_cmp->value) ? 0 : 1);
  }
  cmp_item *make_same();
};


class cmp_item_decimal :public cmp_item
{
  type::Decimal value;
public:
  void store_value(Item *item);
  int cmp(Item *arg);
  int compare(cmp_item *c);
  cmp_item *make_same();
};







class cmp_item_sort_string_in_static :public cmp_item_string
{
 protected:
  String value;
public:
  cmp_item_sort_string_in_static(const charset_info_st * const cs):
    cmp_item_string(cs) {}
  void store_value(Item *item)
  {
    value_res= item->val_str(&value);
  }
  int cmp(Item *)
  {

    ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/item/cmpfunc.h", 1077, __PRETTY_FUNCTION__));
    return 1;
  }
  int compare(cmp_item *ci)
  {
    cmp_item_string *l_cmp= (cmp_item_string *) ci;
    return sortcmp(value_res, l_cmp->value_res, cmp_charset);
  }
  cmp_item *make_same()
  {
    return new cmp_item_sort_string_in_static(cmp_charset);
  }
};
# 1110 "./drizzled/item/cmpfunc.h"
class Item_func_case :public Item_func
{
  int first_expr_num, else_expr_num;
  enum Item_result cached_result_type, left_result_type;
  String tmp_value;
  uint32_t ncases;
  Item_result cmp_type;
  DTCollation cmp_collation;
  enum_field_types cached_field_type;
  cmp_item *cmp_items[DECIMAL_RESULT+1];
  cmp_item *case_item;
public:
  Item_func_case(List<Item> &list, Item *first_expr_arg, Item *else_expr_arg)
    :Item_func(), first_expr_num(-1), else_expr_num(-1),
    cached_result_type(INT_RESULT), left_result_type(INT_RESULT), case_item(0)
  {
    ncases= list.size();
    if (first_expr_arg)
    {
      first_expr_num= list.size();
      list.push_back(first_expr_arg);
    }
    if (else_expr_arg)
    {
      else_expr_num= list.size();
      list.push_back(else_expr_arg);
    }
    set_arguments(list);
    memset(&cmp_items, 0, sizeof(cmp_items));
  }
  double val_real();
  int64_t val_int();
  String *val_str(String *);
  type::Decimal *val_decimal(type::Decimal *);
  bool fix_fields(Session *session, Item **ref);
  void fix_length_and_dec();
  uint32_t decimal_precision() const;
  table_map not_null_tables() const { return 0; }
  enum Item_result result_type () const { return cached_result_type; }
  enum_field_types field_type() const { return cached_field_type; }
  const char *func_name() const { return "case"; }
  virtual void print(String *str);
  Item *find_item(String *str);
  const charset_info_st *compare_collation() { return cmp_collation.collation; }
  void cleanup();
  void agg_str_lengths(Item *arg);
  void agg_num_lengths(Item *arg);
};
# 1173 "./drizzled/item/cmpfunc.h"
class Item_func_in :public Item_func_opt_neg
{
public:




  in_vector *array;
  bool have_null;




  bool arg_types_compatible;
  Item_result left_result_type;
  cmp_item *cmp_items[6];
  DTCollation cmp_collation;

  Item_func_in(List<Item> &list)
    :Item_func_opt_neg(list), array(0), have_null(0),
    arg_types_compatible(false)
  {
    memset(&cmp_items, 0, sizeof(cmp_items));
    allowed_arg_cols= 0;
  }
  int64_t val_int();
  bool fix_fields(Session *, Item **);
  void fix_length_and_dec();
  uint32_t decimal_precision() const { return 1; }
  void cleanup()
  {
    Item_int_func::cleanup();
    delete array;
    array= 0;
    for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
    {
      delete cmp_items[i];
      cmp_items[i]= 0;
    }
    return;
  }
  optimize_type select_optimize() const
    { return OPTIMIZE_KEY; }
  virtual void print(String *str);
  enum Functype functype() const { return IN_FUNC; }
  const char *func_name() const { return " IN "; }
  bool nulls_in_row();
  bool is_bool_func() { return 1; }
  const charset_info_st *compare_collation() { return cmp_collation.collation; }
};

class cmp_item_row :public cmp_item
{
  cmp_item **comparators;
  uint32_t n;
public:
  cmp_item_row(): comparators(0), n(0) {}
  ~cmp_item_row();
  void store_value(Item *item);
  inline void alloc_comparators();
  int cmp(Item *arg);
  int compare(cmp_item *arg);
  cmp_item *make_same();
  void store_value_by_template(cmp_item *tmpl, Item *);
  friend void Item_func_in::fix_length_and_dec();
};


class in_row :public in_vector
{
  cmp_item_row tmp;
public:
  in_row(uint32_t elements, Item *);
  ~in_row();
  void set(uint32_t pos,Item *item);
  unsigned char *get_value(Item *item);
  friend void Item_func_in::fix_length_and_dec();
  Item_result result_type() { return ROW_RESULT; }
};



class Item_func_isnull :public item::function::Boolean
{
protected:
  int64_t cached_value;
public:
  Item_func_isnull(Item *a) :item::function::Boolean(a) {}
  int64_t val_int();
  enum Functype functype() const { return ISNULL_FUNC; }
  void fix_length_and_dec()
  {
    decimals=0; max_length=1; maybe_null=0;
    update_used_tables();
  }
  const char *func_name() const { return "isnull"; }

  virtual void update_used_tables()
  {
    if (!args[0]->maybe_null)
    {
      used_tables_cache= 0;
      const_item_cache= 1;
      cached_value= (int64_t) 0;
    }
    else
    {
      args[0]->update_used_tables();
      if ((const_item_cache= !(used_tables_cache= args[0]->used_tables())) &&
          !with_subselect)
      {

 cached_value= (int64_t) args[0]->is_null();
      }
    }
  }
  table_map not_null_tables() const { return 0; }
  optimize_type select_optimize() const { return OPTIMIZE_NULL; }
  Item *neg_transformer(Session *session);
  const charset_info_st *compare_collation() { return args[0]->collation.collation; }
};







class Item_is_not_null_test :public Item_func_isnull
{
  Item_in_subselect* owner;
public:
  Item_is_not_null_test(Item_in_subselect* ow, Item *a)
    :Item_func_isnull(a), owner(ow)
  {}
  enum Functype functype() const { return ISNOTNULLTEST_FUNC; }
  int64_t val_int();
  const char *func_name() const { return "<is_not_null_test>"; }
  void update_used_tables();



  table_map used_tables() const
    { return used_tables_cache | (((table_map) 1) << (sizeof(table_map)*8-1)); }
};


class Item_func_isnotnull :public item::function::Boolean
{
  bool abort_on_null;
public:
  Item_func_isnotnull(Item *a) :item::function::Boolean(a), abort_on_null(0) {}
  int64_t val_int();
  enum Functype functype() const { return ISNOTNULL_FUNC; }
  void fix_length_and_dec()
  {
    decimals=0; max_length=1; maybe_null=0;
  }
  const char *func_name() const { return "isnotnull"; }
  optimize_type select_optimize() const { return OPTIMIZE_NULL; }
  table_map not_null_tables() const
  { return abort_on_null ? not_null_tables_cache : 0; }
  Item *neg_transformer(Session *session);
  virtual void print(String *str);
  const charset_info_st *compare_collation() { return args[0]->collation.collation; }
  void top_level_item() { abort_on_null=1; }
};


class Item_func_like :public Item_bool_func2
{

  bool canDoTurboBM;
  const char* pattern;
  int pattern_len;


  int* bmGs;
  int* bmBc;

  void turboBM_compute_suffixes(int* suff);
  void turboBM_compute_good_suffix_shifts(int* suff);
  void turboBM_compute_bad_character_shifts();
  bool turboBM_matches(const char* text, int text_len) const;
  enum { alphabet_size = 256 };

  Item *escape_item;

  bool escape_used_in_parsing;


public:

  char *escape;

  Item_func_like(Item *a,Item *b, Item *escape_arg, bool escape_used)
    :Item_bool_func2(a,b), canDoTurboBM(false), pattern(0), pattern_len(0),
     bmGs(0), bmBc(0), escape_item(escape_arg),
     escape_used_in_parsing(escape_used), escape(__null) {}
  int64_t val_int();
  enum Functype functype() const { return LIKE_FUNC; }
  optimize_type select_optimize() const;
  cond_result eq_cmp_result() const { return COND_TRUE; }
  const char *func_name() const { return "like"; }
  bool fix_fields(Session *session, Item **ref);
  void cleanup();
};


class Item_cond :public item::function::Boolean
{
protected:
  List<Item> list;
  bool abort_on_null;
  table_map and_tables_cache;

public:

  using Item::split_sum_func;


  Item_cond(): item::function::Boolean(), abort_on_null(1)
  { const_item_cache=0; }
  Item_cond(Item *i1,Item *i2)
    :item::function::Boolean(), abort_on_null(0)
  {
    list.push_back(i1);
    list.push_back(i2);
  }
  Item_cond(Session *session, Item_cond *item);
  Item_cond(List<Item> &nlist)
    :item::function::Boolean(), list(nlist), abort_on_null(0) {}
  void add(Item *item) { list.push_back(item); }
  void add_at_head(Item *item) { list.push_front(item); }
  void add_at_head(List<Item> *nlist) { list.prepand(nlist); }
  bool fix_fields(Session *, Item **ref);
  void fix_after_pullout(Select_Lex *new_parent, Item **ref);

  enum Type type() const { return COND_ITEM; }
  List<Item>* argument_list() { return &list; }
  table_map used_tables() const;
  void update_used_tables();
  virtual void print(String *str);
  void split_sum_func(Session *session, Item **ref_pointer_array, List<Item> &fields);
  friend int setup_conds(Session *session, TableList *tables, TableList *leaves,
                         COND **conds);
  void top_level_item() { abort_on_null=1; }
  void copy_andor_arguments(Session *session, Item_cond *item);
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);
  Item *transform(Item_transformer transformer, unsigned char *arg);
  void traverse_cond(Cond_traverser, void *arg, traverse_order order);
  void neg_arguments(Session *session);
  enum_field_types field_type() const { return DRIZZLE_TYPE_LONGLONG; }
  bool subst_argument_checker(unsigned char **)
  { return true; }
  Item *compile(Item_analyzer analyzer, unsigned char **arg_p,
                Item_transformer transformer, unsigned char *arg_t);
};
# 1508 "./drizzled/item/cmpfunc.h"
class Item_equal: public item::function::Boolean
{
public:
  typedef List<Item_field> fields_t;

  Item_equal() :
    const_item(0),
    eval_item(0),
    cond_false(0)
  {
    const_item_cache=0;
  }

  fields_t::iterator begin()
  {
    return fields.begin();
  }

  Item_equal(Item_field *f1, Item_field *f2);
  Item_equal(Item *c, Item_field *f);
  Item_equal(Item_equal *item_equal);
  inline Item* get_const() { return const_item; }
  void add(Item *c);
  void add(Item_field *f);
  uint32_t members();
  bool contains(Field *field);
  Item_field* get_first() { return &fields.front(); }
  void merge(Item_equal *item);
  void update_const();
  enum Functype functype() const { return MULT_EQUAL_FUNC; }
  int64_t val_int();
  const char *func_name() const { return "multiple equal"; }
  optimize_type select_optimize() const { return OPTIMIZE_EQUAL; }
  void sort(Item_field_cmpfunc cmp, void *arg);
  void fix_length_and_dec();
  bool fix_fields(Session *session, Item **ref);
  void update_used_tables();
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);
  Item *transform(Item_transformer transformer, unsigned char *arg);
  virtual void print(String *str);
  const charset_info_st *compare_collation()
  { return fields.front().collation.collation; }
private:
  fields_t fields;
  Item *const_item;
  cmp_item *eval_item;
  bool cond_false;

};

class COND_EQUAL: public memory::SqlAlloc
{
public:
  uint32_t max_members;

  COND_EQUAL *upper_levels;
  List<Item_equal> current_level;

  COND_EQUAL()
  {
    upper_levels= 0;
  }
};

typedef List<Item_field>::iterator Item_equal_iterator;

class Item_cond_and :public Item_cond
{
public:
  COND_EQUAL cond_equal;


  Item_cond_and() :Item_cond() {}
  Item_cond_and(Item *i1,Item *i2) :Item_cond(i1,i2) {}
  Item_cond_and(Session *session, Item_cond_and *item) :Item_cond(session, item) {}
  Item_cond_and(List<Item> &list_arg): Item_cond(list_arg) {}
  enum Functype functype() const { return COND_AND_FUNC; }
  int64_t val_int();
  const char *func_name() const { return "and"; }
  table_map not_null_tables() const
  { return abort_on_null ? not_null_tables_cache: and_tables_cache; }
  Item* copy_andor_structure(Session *session)
  {
    Item_cond_and *item;
    item= new Item_cond_and(session, this);
    item->copy_andor_arguments(session, this);
    return item;
  }
  Item *neg_transformer(Session *session);
};

inline bool is_cond_and(Item *item)
{
  if (item->type() != Item::COND_ITEM)
    return false;

  Item_cond *cond_item= (Item_cond*) item;
  return (cond_item->functype() == Item_func::COND_AND_FUNC);
}

class Item_cond_or :public Item_cond
{
public:
  Item_cond_or() :Item_cond() {}
  Item_cond_or(Item *i1,Item *i2) :Item_cond(i1,i2) {}
  Item_cond_or(Session *session, Item_cond_or *item) :Item_cond(session, item) {}
  Item_cond_or(List<Item> &list_arg): Item_cond(list_arg) {}
  enum Functype functype() const { return COND_OR_FUNC; }
  int64_t val_int();
  const char *func_name() const { return "or"; }
  table_map not_null_tables() const { return and_tables_cache; }
  Item* copy_andor_structure(Session *session)
  {
    Item_cond_or *item;
    item= new Item_cond_or(session, this);
    item->copy_andor_arguments(session, this);
    return item;
  }
  Item *neg_transformer(Session *session);
};

inline bool is_cond_or(Item *item)
{
  if (item->type() != Item::COND_ITEM)
    return false;

  Item_cond *cond_item= (Item_cond*) item;
  return (cond_item->functype() == Item_func::COND_OR_FUNC);
}






class Item_cond_xor :public Item_cond
{
public:
  Item_cond_xor() :Item_cond() {}
  Item_cond_xor(Item *i1,Item *i2) :Item_cond(i1,i2) {}
  enum Functype functype() const { return COND_XOR_FUNC; }

  enum Type type() const { return FUNC_ITEM; }
  int64_t val_int();
  const char *func_name() const { return "xor"; }
  void top_level_item() {}
};

enum_field_types agg_field_type(Item **items, uint32_t nitems);




inline Item *and_conds(Item *a, Item *b)
{
  if (!b) return a;
  if (!a) return b;
  return new Item_cond_and(a, b);
}

Item *and_expressions(Item *a, Item *b, Item **org_item);

}
# 33 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/item/int_with_ref.h" 1
# 20 "./drizzled/item/int_with_ref.h"
       
# 31 "./drizzled/item/int_with_ref.h"
namespace drizzled {

class Item_int_with_ref :public Item_int
{
  Item *ref;
public:
  Item_int_with_ref(int64_t i, Item *ref_arg, bool unsigned_arg) :
    Item_int(i), ref(ref_arg)
  {
    unsigned_flag= unsigned_arg;
  }
  int save_in_field(Field *field, bool no_conversions)
  {
    return ref->save_in_field(field, no_conversions);
  }
  Item *clone_item();
  virtual Item *real_item() { return ref; }
  virtual const Item *real_item() const { return ref; }
};

}
# 34 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/item/subselect.h" 1
# 20 "./drizzled/item/subselect.h"
       


# 1 "./drizzled/item/ref.h" 1
# 20 "./drizzled/item/ref.h"
       



namespace drizzled {

class Item_ref :public Item_ident
{
protected:
  void set_properties();
public:
  enum Ref_Type { REF, DIRECT_REF, OUTER_REF };
  Field *result_field;
  Item **ref;
  Item_ref(Name_resolution_context *context_arg,
           const char *db_arg, const char *table_name_arg,
           const char *field_name_arg)
    :Item_ident(context_arg, db_arg, table_name_arg, field_name_arg),
     result_field(0), ref(0) {}
# 53 "./drizzled/item/ref.h"
  Item_ref(Name_resolution_context *context_arg, Item **item,
           const char *table_name_arg, const char *field_name_arg,
           bool alias_name_used_arg= false);


  Item_ref(Session *session, Item_ref *item)
    :Item_ident(session, item), result_field(item->result_field), ref(item->ref) {}
  enum Type type() const { return REF_ITEM; }
  bool eq(const Item *item, bool binary_cmp) const
  {
    const Item *it= item->real_item();
    return ref && (*ref)->eq(it, binary_cmp);
  }
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal *);
  bool val_bool();
  String *val_str(String* tmp);
  bool is_null();
  bool get_date(type::Time &ltime,uint32_t fuzzydate);
  double val_result();
  int64_t val_int_result();
  String *str_result(String* tmp);
  type::Decimal *val_decimal_result(type::Decimal *);
  bool val_bool_result();
  void send(plugin::Client *client, String *tmp);
  void make_field(SendField *field);
  bool fix_fields(Session *, Item **);
  void fix_after_pullout(Select_Lex *new_parent, Item **ref);
  int save_in_field(Field *field, bool no_conversions);
  void save_org_in_field(Field *field);
  enum Item_result result_type () const { return (*ref)->result_type(); }
  enum_field_types field_type() const { return (*ref)->field_type(); }
  Field *get_tmp_table_field()
  { return result_field ? result_field : (*ref)->get_tmp_table_field(); }
  Item *get_tmp_table_item(Session *session);
  table_map used_tables() const
  {
    return depended_from ? (((table_map) 1) << (sizeof(table_map)*8-2)) : (*ref)->used_tables();
  }
  void update_used_tables()
  {
    if (!depended_from)
      (*ref)->update_used_tables();
  }
  table_map not_null_tables() const { return (*ref)->not_null_tables(); }
  void set_result_field(Field *field) { result_field= field; }
  bool is_result_field() { return 1; }
  void save_in_result_field(bool no_conversions)
  {
    (*ref)->save_in_field(result_field, no_conversions);
  }
  Item *real_item(void)
  {
    return ref ? (*ref)->real_item() : this;
  }
  const Item *real_item(void) const
  {
    return ref ? (*ref)->real_item() : this;
  }
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
  { return (*ref)->walk(processor, walk_subquery, arg); }
  virtual void print(String *str);
  bool result_as_int64_t()
  {
    return (*ref)->result_as_int64_t();
  }
  void cleanup();
  virtual Ref_Type ref_type() { return REF; }


  uint32_t cols()
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->cols() : 1;
  }
  Item* element_index(uint32_t i)
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->element_index(i) : this;
  }
  Item** addr(uint32_t i)
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->addr(i) : 0;
  }
  bool check_cols(uint32_t c)
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->check_cols(c)
                                              : Item::check_cols(c);
  }
  bool null_inside()
  {
    return ref && result_type() == ROW_RESULT ? (*ref)->null_inside() : 0;
  }
  void bring_value()
  {
    if (ref && result_type() == ROW_RESULT)
      (*ref)->bring_value();
  }
  bool basic_const_item() const
  {
    return (*ref)->basic_const_item();
  }
};

}
# 24 "./drizzled/item/subselect.h" 2




namespace drizzled {

class Item_subselect : public Item_result_field
{
  bool value_assigned;
public:

  Session *session;

  Item *substitution;

  Select_Lex_Unit *unit;
protected:

  subselect_engine *engine;

  subselect_engine *old_engine;

  table_map used_tables_cache;

  uint32_t max_columns;

  enum_parsing_place parsing_place;

  bool have_to_be_excluded;

  bool const_item_cache;

public:

  bool engine_changed;

  bool changed;


  bool is_correlated;

  enum trans_res {RES_OK, RES_REDUCE, RES_ERROR};
  enum subs_type {UNKNOWN_SUBS, SINGLEROW_SUBS,
    EXISTS_SUBS, IN_SUBS, ALL_SUBS, ANY_SUBS};

  Item_subselect();

  virtual subs_type substype() { return UNKNOWN_SUBS; }






  virtual void init (Select_Lex *select_lex,
       select_result_interceptor *result);

  ~Item_subselect();
  void cleanup();
  virtual void reset()
  {
    null_value= 1;
  }
  virtual trans_res select_transformer(Join *join);
  bool assigned() { return value_assigned; }
  void assigned(bool a) { value_assigned= a; }
  enum Type type() const;
  bool is_null()
  {
    update_null_value();
    return null_value;
  }
  bool fix_fields(Session *session, Item **ref);
  virtual bool exec();
  virtual void fix_length_and_dec();
  table_map used_tables() const;
  table_map not_null_tables() const { return 0; }
  bool const_item() const;
  inline table_map get_used_tables_cache() { return used_tables_cache; }
  inline bool get_const_item_cache() { return const_item_cache; }
  Item *get_tmp_table_item(Session *session);
  void update_used_tables();
  virtual void print(String *str);
  virtual bool have_guarded_conds() { return false; }
  bool change_engine(subselect_engine *eng)
  {
    old_engine= engine;
    engine= eng;
    engine_changed= 1;
    return eng == 0;
  }




  bool is_evaluated() const;
  bool is_uncacheable() const;





  virtual void reset_value_registration() {}
  enum_parsing_place place() { return parsing_place; }
  bool walk(Item_processor processor, bool walk_subquery, unsigned char *arg);





  Select_Lex* get_select_lex();

  friend class select_result_interceptor;
  friend class Item_in_optimizer;
  friend bool Item_field::fix_fields(Session *, Item **);
  friend int Item_field::fix_outer_field(Session *, Field **, Item **);
  friend bool Item_ref::fix_fields(Session *, Item **);
  friend void mark_select_range_as_dependent(Session*,
                                             Select_Lex*, Select_Lex*,
                                             Field*, Item*, Item_ident*);
};



class Item_singlerow_subselect :public Item_subselect
{
protected:
  Item_cache *value, **row;
public:
  Item_singlerow_subselect(Select_Lex *select_lex);
  Item_singlerow_subselect() :Item_subselect(), value(0), row (0) {}

  void cleanup();
  subs_type substype() { return SINGLEROW_SUBS; }

  void reset();
  trans_res select_transformer(Join *join);
  void store(uint32_t i, Item* item);
  double val_real();
  int64_t val_int ();
  String *val_str (String *);
  type::Decimal *val_decimal(type::Decimal *);
  bool val_bool();
  enum Item_result result_type() const;
  enum_field_types field_type() const;
  void fix_length_and_dec();

  uint32_t cols();
  Item* element_index(uint32_t i) { return reinterpret_cast<Item*>(row[i]); }
  Item** addr(uint32_t i) { return (Item**)row + i; }
  bool check_cols(uint32_t c);
  bool null_inside();
  void bring_value();
# 190 "./drizzled/item/subselect.h"
  Select_Lex* invalidate_and_restore_select_lex();

  friend class select_singlerow_subselect;
};


class Item_maxmin_subselect :public Item_singlerow_subselect
{
protected:
  bool max;
  bool was_values;
public:
  Item_maxmin_subselect(Session *session, Item_subselect *parent,
   Select_Lex *select_lex, bool max);
  virtual void print(String *str);
  void cleanup();
  bool any_value() { return was_values; }
  void register_value() { was_values= true; }
  void reset_value_registration() { was_values= false; }
};



class Item_exists_subselect :public Item_subselect
{
protected:
  bool value;

public:
  Item_exists_subselect(Select_Lex *select_lex);
  Item_exists_subselect(): Item_subselect() {}

  subs_type substype() { return EXISTS_SUBS; }
  void reset()
  {
    value= 0;
  }

  enum Item_result result_type() const { return INT_RESULT;}
  int64_t val_int();
  double val_real();
  String *val_str(String*);
  type::Decimal *val_decimal(type::Decimal *);
  bool val_bool();
  void fix_length_and_dec();
  virtual void print(String *str);

  friend class select_exists_subselect;
  friend class subselect_uniquesubquery_engine;
  friend class subselect_indexsubquery_engine;
};
# 258 "./drizzled/item/subselect.h"
class Item_in_subselect :public Item_exists_subselect
{
public:
  Item *left_expr;
protected:




  List<Cached_item> *left_expr_cache;
  bool first_execution;





  Item *expr;
  Item_in_optimizer *optimizer;
  bool was_null;
  bool abort_on_null;

public:

  bool *pushed_cond_guards;


  int sj_convert_priority;






  TableList *expr_join_nest;


  enum enum_exec_method {
    NOT_TRANSFORMED,
    SEMI_JOIN,
    IN_TO_EXISTS,
    MATERIALIZATION
  };
  enum_exec_method exec_method;

  bool *get_cond_guard(int i)
  {
    return pushed_cond_guards ? pushed_cond_guards + i : __null;
  }
  void set_cond_guard_var(int i, bool v)
  {
    if ( pushed_cond_guards)
      pushed_cond_guards[i]= v;
  }
  bool have_guarded_conds() { return test(pushed_cond_guards); }

  Item_func_not_all *upper_item;

  Item_in_subselect(Item * left_expr, Select_Lex *select_lex);
  Item_in_subselect()
    :
      Item_exists_subselect(),
      left_expr(__null),
      left_expr_cache(__null),
      first_execution(true),
      optimizer(__null),
      abort_on_null(false),
      pushed_cond_guards(__null),
      sj_convert_priority(0),
      expr_join_nest(__null),
      exec_method(NOT_TRANSFORMED),
      upper_item(__null)
  {}
  void cleanup();
  subs_type substype() { return IN_SUBS; }
  void reset()
  {
    value= 0;
    null_value= 0;
    was_null= 0;
  }
  trans_res select_transformer(Join *join);
  trans_res select_in_like_transformer(Join *join, const Comp_creator *func);
  trans_res single_value_transformer(Join *join, const Comp_creator *func);
  trans_res row_value_transformer(Join * join);
  trans_res single_value_in_to_exists_transformer(Join * join,
                                                  const Comp_creator *func);
  trans_res row_value_in_to_exists_transformer(Join * join);
  virtual bool exec();
  int64_t val_int();
  double val_real();
  String *val_str(String*);
  type::Decimal *val_decimal(type::Decimal *);
  void update_null_value () { (void) val_bool(); }
  bool val_bool();
  void top_level_item() { abort_on_null=1; }
  inline bool is_top_level_item() { return abort_on_null; }
  bool test_limit(Select_Lex_Unit *unit);
  virtual void print(String *str);
  bool fix_fields(Session *session, Item **ref);
  bool setup_engine();
  bool init_left_expr_cache();
  bool is_expensive_processor(unsigned char *arg);

  friend class Item_ref_null_helper;
  friend class Item_is_not_null_test;
  friend class Item_in_optimizer;
  friend class subselect_indexsubquery_engine;
  friend class subselect_hash_sj_engine;
};



class Item_allany_subselect :public Item_in_subselect
{
public:
  chooser_compare_func_creator func_creator;
  Comp_creator *func;
  bool all;

  Item_allany_subselect(Item * left_expr, chooser_compare_func_creator fc,
                        Select_Lex *select_lex, bool all);


  subs_type substype() { return all?ALL_SUBS:ANY_SUBS; }
  trans_res select_transformer(Join *join);
  virtual void print(String *str);
};


class subselect_engine: public memory::SqlAlloc
{
protected:
  select_result_interceptor *result;
  Session *session;
  Item_subselect *item;
  enum Item_result res_type;
  enum_field_types res_field_type;
  bool maybe_null;
public:

  enum enum_engine_type {ABSTRACT_ENGINE, SINGLE_SELECT_ENGINE,
                         UNION_ENGINE, UNIQUESUBQUERY_ENGINE,
                         INDEXSUBQUERY_ENGINE, HASH_SJ_ENGINE};

  subselect_engine(Item_subselect *si, select_result_interceptor *res)
    :session(__null)
  {
    result= res;
    item= si;
    res_type= STRING_RESULT;
    res_field_type= DRIZZLE_TYPE_VARCHAR;
    maybe_null= 0;
  }
  virtual ~subselect_engine() {}
  virtual void cleanup()= 0;





  void set_session(Session *session_arg);
  Session * get_session() { return session; }
  virtual int prepare()= 0;
  virtual void fix_length_and_dec(Item_cache** row)= 0;
# 442 "./drizzled/item/subselect.h"
  virtual int exec()= 0;
  virtual uint32_t cols()= 0;
  virtual bool uncacheable()= 0;
  virtual bool uncacheable(uint32_t bit_pos)= 0;
  enum Item_result type() { return res_type; }
  enum_field_types field_type() { return res_field_type; }
  virtual void exclude()= 0;
  virtual bool may_be_null() { return maybe_null; }
  virtual table_map upper_select_const_tables()= 0;
  static table_map calc_const_tables(TableList *);
  virtual void print(String *str)= 0;
  virtual bool change_result(Item_subselect *si,
                             select_result_interceptor *result)= 0;
  virtual bool no_tables()= 0;
  virtual bool is_executed() const { return false; }

  virtual bool no_rows() = 0;
  virtual enum_engine_type engine_type() { return ABSTRACT_ENGINE; }

protected:
  void set_row(List<Item> &item_list, Item_cache **row);
};


class subselect_single_select_engine: public subselect_engine
{
  bool prepared;
  bool optimized;
  bool executed;
  Select_Lex *select_lex;
  Join * join;
public:
  subselect_single_select_engine(Select_Lex *select,
     select_result_interceptor *result,
     Item_subselect *item);
  void cleanup();
  int prepare();
  void fix_length_and_dec(Item_cache** row);
  int exec();
  uint32_t cols();
  bool uncacheable();
  bool uncacheable(uint32_t bit_pos);
  void exclude();
  table_map upper_select_const_tables();
  virtual void print (String *str);
  bool change_result(Item_subselect *si, select_result_interceptor *result);
  bool no_tables();
  bool may_be_null();
  bool is_executed() const { return executed; }
  bool no_rows();
  virtual enum_engine_type engine_type() { return SINGLE_SELECT_ENGINE; }
  void save_join_if_explain();

  friend class subselect_hash_sj_engine;
  friend class Item_in_subselect;
};


class subselect_union_engine: public subselect_engine
{
  Select_Lex_Unit *unit;
public:
  subselect_union_engine(Select_Lex_Unit *u,
    select_result_interceptor *result,
    Item_subselect *item);
  void cleanup();
  int prepare();
  void fix_length_and_dec(Item_cache** row);
  int exec();
  uint32_t cols();
  bool uncacheable();
  bool uncacheable(uint32_t bit_pos);
  void exclude();
  table_map upper_select_const_tables();
  virtual void print (String *str);
  bool change_result(Item_subselect *si, select_result_interceptor *result);
  bool no_tables();
  bool is_executed() const;
  bool no_rows();
  virtual enum_engine_type engine_type() { return UNION_ENGINE; }
};
# 542 "./drizzled/item/subselect.h"
class subselect_uniquesubquery_engine: public subselect_engine
{
protected:
  JoinTable *tab;
  Item *cond;




  bool empty_result_set;
  bool null_keypart;
public:


  subselect_uniquesubquery_engine(Session *session_arg, JoinTable *tab_arg,
      Item_subselect *subs, Item *where)
    :subselect_engine(subs, 0), tab(tab_arg), cond(where)
  {
    set_session(session_arg);
  }
  void cleanup();
  int prepare();
  void fix_length_and_dec(Item_cache** row);
  int exec();
  uint32_t cols() { return 1; }
  bool uncacheable() { return true; }
  bool uncacheable(uint32_t) { return true; }
  void exclude();
  table_map upper_select_const_tables() { return 0; }
  virtual void print (String *str);
  bool change_result(Item_subselect *si, select_result_interceptor *result);
  bool no_tables();
  int scan_table();
  bool copy_ref_key();
  bool no_rows() { return empty_result_set; }
  virtual enum_engine_type engine_type() { return UNIQUESUBQUERY_ENGINE; }
};


class subselect_indexsubquery_engine: public subselect_uniquesubquery_engine
{

  bool check_null;
# 614 "./drizzled/item/subselect.h"
  Item *having;
public:


  subselect_indexsubquery_engine(Session *session_arg, JoinTable *tab_arg,
     Item_subselect *subs, Item *where,
                                 Item *having_arg, bool chk_null)
    :subselect_uniquesubquery_engine(session_arg, tab_arg, subs, where),
     check_null(chk_null),
     having(having_arg)
  {}
  int exec();
  virtual void print (String *str);
  virtual enum_engine_type engine_type() { return INDEXSUBQUERY_ENGINE; }
};


inline bool Item_subselect::is_evaluated() const
{
  return engine->is_executed();
}


inline bool Item_subselect::is_uncacheable() const
{
  return engine->uncacheable();
}
# 649 "./drizzled/item/subselect.h"
class subselect_hash_sj_engine: public subselect_uniquesubquery_engine
{
protected:

  bool is_materialized;






  subselect_single_select_engine *materialize_engine;




  Join *materialize_join;

  Tmp_Table_Param *tmp_param;

public:
  subselect_hash_sj_engine(Session *session_in, Item_subselect *in_predicate,
                               subselect_single_select_engine *old_engine)
    :subselect_uniquesubquery_engine(session_in, __null, in_predicate, __null),
    is_materialized(false), materialize_engine(old_engine),
    materialize_join(__null), tmp_param(__null)
  {}
  ~subselect_hash_sj_engine();

  bool init_permanent(List<Item> *tmp_columns);
  void init_runtime();
  void cleanup();
  int prepare() { return 0; }
  int exec();
  virtual void print (String *str);
  uint32_t cols()
  {
    return materialize_engine->cols();
  }
  virtual enum_engine_type engine_type() { return HASH_SJ_ENGINE; }
};

}
# 35 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/session.h" 1
# 20 "./drizzled/session.h"
       



# 1 "/usr/include/boost/make_shared.hpp" 1 3 4
# 15 "/usr/include/boost/make_shared.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/make_shared.hpp" 1 3 4
# 15 "/usr/include/boost/smart_ptr/make_shared.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 1 3 4
# 17 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_forward.hpp" 1 3 4
# 20 "/usr/include/boost/smart_ptr/detail/sp_forward.hpp" 3 4
namespace boost
{

namespace detail
{
# 35 "/usr/include/boost/smart_ptr/detail/sp_forward.hpp" 3 4
}

}
# 18 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4


# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 21 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 2 3 4


namespace boost
{

namespace detail
{

template< std::size_t N, std::size_t A > struct sp_aligned_storage
{
    union type
    {
        char data_[ N ];
        typename boost::type_with_alignment< A >::type align_;
    };
};

template< class T > class sp_ms_deleter
{
private:

    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;

    bool initialized_;
    storage_type storage_;

private:

    void destroy()
    {
        if( initialized_ )
        {



            T * p = reinterpret_cast< T* >( storage_.data_ );
            p->~T();







            initialized_ = false;
        }
    }

public:

    sp_ms_deleter() : initialized_( false )
    {
    }


    sp_ms_deleter( sp_ms_deleter const & ) : initialized_( false )
    {
    }

    ~sp_ms_deleter()
    {
        destroy();
    }

    void operator()( T * )
    {
        destroy();
    }

    void * address()
    {
        return storage_.data_;
    }

    void set_initialized()
    {
        initialized_ = true;
    }
};

template< class T > struct sp_if_not_array
{
    typedef boost::shared_ptr< T > type;
};



template< class T > struct sp_if_not_array< T[] >
{
};



template< class T, std::size_t N > struct sp_if_not_array< T[N] >
{
};





}
# 134 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 3 4
template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T();
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T;
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T();
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T;
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}
# 698 "/usr/include/boost/smart_ptr/make_shared_object.hpp" 3 4
template< class T, class A1 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3, class A4 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3, class A4 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3, class A4, class A5 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
typename boost::detail::sp_if_not_array< T >::type make_shared( 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 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >() );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}

template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, 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 )
{
    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >(), a );

    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );

    void * pv = pd->address();

    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
    pd->set_initialized();

    T * pt2 = static_cast< T* >( pv );

    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
    return boost::shared_ptr< T >( pt, pt2 );
}





}
# 16 "/usr/include/boost/smart_ptr/make_shared.hpp" 2 3 4


# 1 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 1 3 4
# 13 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/array_deleter.hpp" 1 3 4
# 12 "/usr/include/boost/smart_ptr/detail/array_deleter.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/array_utility.hpp" 1 3 4
# 16 "/usr/include/boost/smart_ptr/detail/array_utility.hpp" 3 4
namespace boost {
    namespace detail {
        template<typename T>
        inline void array_destroy(T*, std::size_t, boost::true_type) {
        }
        template<typename T>
        inline void array_destroy(T* memory, std::size_t size, boost::false_type) {
            for (std::size_t i = size; i > 0; ) {
                memory[--i].~T();
            }
        }
        template<typename T>
        inline void array_destroy(T* memory, std::size_t size) {
            boost::has_trivial_destructor<T> type;
            array_destroy(memory, size, type);
        }
        template<typename T>
        inline void array_init(T* memory, std::size_t size, boost::true_type) {
            for (std::size_t i = 0; i < size; i++) {
                memory[i] = T();
            }
        }
        template<typename T>
        inline void array_init(T* memory, std::size_t size, boost::false_type) {

            std::size_t i = 0;
            try {
                for (; i < size; i++) {
                    void* p1 = memory + i;
                    ::new(p1) T();
                }
            } catch (...) {
                array_destroy(memory, i);
                throw;
            }






        }
        template<typename T>
        inline void array_init(T* memory, std::size_t size) {
            boost::has_trivial_default_constructor<T> type;
            array_init(memory, size, type);
        }
# 107 "/usr/include/boost/smart_ptr/detail/array_utility.hpp" 3 4
        template<typename T>
        inline void array_init_list(T* memory, std::size_t size, const T* list) {

            std::size_t i = 0;
            try {
                for (; i < size; i++) {
                    void* p1 = memory + i;
                    ::new(p1) T(list[i]);
                }
            } catch (...) {
                array_destroy(memory, i);
                throw;
            }






        }
        template<typename T, std::size_t N>
        inline void array_init_list(T* memory, std::size_t size, const T* list) {

            std::size_t i = 0;
            try {
                for (; i < size; i++) {
                    void* p1 = memory + i;
                    ::new(p1) T(list[i % N]);
                }
            } catch (...) {
                array_destroy(memory, i);
                throw;
            }






        }
        template<typename T>
        inline void array_noinit(T*, std::size_t, boost::true_type) {
        }
        template<typename T>
        inline void array_noinit(T* memory, std::size_t size, boost::false_type) {

            std::size_t i = 0;
            try {
                for (; i < size; i++) {
                    void* p1 = memory + i;
                    ::new(p1) T;
                }
            } catch (...) {
                array_destroy(memory, i);
                throw;
            }






        }
        template<typename T>
        inline void array_noinit(T* memory, std::size_t size) {
            boost::has_trivial_default_constructor<T> type;
            array_noinit(memory, size, type);
        }
    }
}
# 13 "/usr/include/boost/smart_ptr/detail/array_deleter.hpp" 2 3 4


namespace boost {
    namespace detail {
        template<typename T>
        class array_deleter;
        template<typename T>
        class array_deleter<T[]> {
        public:
            array_deleter(std::size_t size)
                : size(size),
                  object(0) {
            }
            ~array_deleter() {
                if (object) {
                    array_destroy(object, size);
                }
            }
            void init(T* memory) {
                array_init(memory, size);
                object = memory;
            }
# 48 "/usr/include/boost/smart_ptr/detail/array_deleter.hpp" 3 4
            void init_list(T* memory, const T* list) {
                array_init_list(memory, size, list);
                object = memory;
            }
            template<std::size_t M>
            void init_list(T* memory, const T* list) {
                array_init_list<T, M>(memory, size, list);
                object = memory;
            }
            void noinit(T* memory) {
                array_noinit(memory, size);
                object = memory;
            }
            void operator()(const void*) {
                if (object) {
                    array_destroy(object, size);
                    object = 0;
                }
            }
        private:
            std::size_t size;
            T* object;
        };
        template<typename T, std::size_t N>
        class array_deleter<T[N]> {
        public:
            array_deleter()
                : object(0) {
            }
            ~array_deleter() {
                if (object) {
                    array_destroy(object, N);
                }
            }
            void init(T* memory) {
                array_init(memory, N);
                object = memory;
            }
# 99 "/usr/include/boost/smart_ptr/detail/array_deleter.hpp" 3 4
            void init_list(T* memory, const T* list) {
                array_init_list(memory, N, list);
                object = memory;
            }
            template<std::size_t M>
            void init_list(T* memory, const T* list) {
                array_init_list<T, M>(memory, N, list);
                object = memory;
            }
            void noinit(T* memory) {
                array_noinit(memory, N);
                object = memory;
            }
            void operator()(const void*) {
                if (object) {
                    array_destroy(object, N);
                    object = 0;
                }
            }
        private:
            T* object;
        };
    }
}
# 14 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/array_traits.hpp" 1 3 4
# 14 "/usr/include/boost/smart_ptr/detail/array_traits.hpp" 3 4
namespace boost {
    namespace detail {
        template<typename T>
        struct array_base {
            typedef typename boost::remove_cv<T>::type type;
        };
        template<typename T>
        struct array_base<T[]> {
            typedef typename array_base<T>::type type;
        };
        template<typename T, std::size_t N>
        struct array_base<T[N]> {
            typedef typename array_base<T>::type type;
        };
        template<typename T>
        struct array_total {
            enum {
                size = 1
            };
        };
        template<typename T, std::size_t N>
        struct array_total<T[N]> {
            enum {
                size = N * array_total<T>::size
            };
        };
        template<typename T>
        struct array_inner;
        template<typename T>
        struct array_inner<T[]> {
            typedef T type;
        };
        template<typename T, std::size_t N>
        struct array_inner<T[N]> {
            typedef T type;
        };
    }
}
# 15 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/make_array_helper.hpp" 1 3 4
# 14 "/usr/include/boost/smart_ptr/detail/make_array_helper.hpp" 3 4
namespace boost {
    namespace detail {
        template<typename T, typename Y = char>
        class make_array_helper;
        template<typename T, typename Y>
        class make_array_helper<T[], Y> {
            template<typename T2, typename Y2>
            friend class make_array_helper;
        public:
            typedef Y value_type;
            typedef Y* pointer;
            typedef const Y* const_pointer;
            typedef Y& reference;
            typedef const Y& const_reference;
            typedef std::size_t size_type;
            typedef ptrdiff_t difference_type;
            template<typename U>
            struct rebind {
                typedef make_array_helper<T[], U> other;
            };
            make_array_helper(std::size_t size, T** data)
                : size(sizeof(T) * size),
                  data(data) {
            }
            template<class U>
            make_array_helper(const make_array_helper<T[], U>& other)
                : size(other.size),
                  data(other.data) {
            }
            pointer address(reference value) const {
                return &value;
            }
            const_pointer address(const_reference value) const {
                return &value;
            }
            size_type max_size() const {
                return static_cast<std::size_t>(-1) / sizeof(Y);
            }
            pointer allocate(size_type count, const void* = 0) {
                std::size_t a1 = boost::alignment_of<T>::value;
                std::size_t n1 = count * sizeof(Y) + a1 - 1;
                void* p1 = ::operator new(n1 + size);
                char* p2 = static_cast<char*>(p1) + n1;
                while (std::size_t(p2) % a1 != 0) {
                    p2--;
                }
                *data = reinterpret_cast<T*>(p2);
                return reinterpret_cast<Y*>(p1);
            }
            void deallocate(pointer memory, size_type) {
                void* p1 = memory;
                ::operator delete(p1);
            }
            void construct(pointer memory, const Y& value) {
                void* p1 = memory;
                ::new(p1) Y(value);
            }
            void destroy(pointer memory) {
                memory->~Y();
            }
            template<typename U>
            bool operator==(const make_array_helper<T[], U>& other) const {
                return true;
            }
            template<typename U>
            bool operator!=(const make_array_helper<T[], U>& other) const {
                return !(*this == other);
            }
        private:
            std::size_t size;
            T** data;
        };
        template<typename T, std::size_t N, typename Y>
        class make_array_helper<T[N], Y> {
            template<typename T2, typename Y2>
            friend class make_array_helper;
        public:
            typedef Y value_type;
            typedef Y* pointer;
            typedef const Y* const_pointer;
            typedef Y& reference;
            typedef const Y& const_reference;
            typedef std::size_t size_type;
            typedef ptrdiff_t difference_type;
            template<typename U>
            struct rebind {
                typedef make_array_helper<T[N], U> other;
            };
            make_array_helper(T** data)
                : data(data) {
            }
            template<class U>
            make_array_helper(const make_array_helper<T[N], U>& other)
                : data(other.data) {
            }
            pointer address(reference value) const {
                return &value;
            }
            const_pointer address(const_reference value) const {
                return &value;
            }
            size_type max_size() const {
                return static_cast<std::size_t>(-1) / sizeof(Y);
            }
            pointer allocate(size_type count, const void* = 0) {
                std::size_t a1 = boost::alignment_of<T>::value;
                std::size_t n1 = count * sizeof(Y) + a1 - 1;
                void* p1 = ::operator new(n1 + N1);
                char* p2 = static_cast<char*>(p1) + n1;
                while (std::size_t(p2) % a1 != 0) {
                    p2--;
                }
                *data = reinterpret_cast<T*>(p2);
                return reinterpret_cast<Y*>(p1);
            }
            void deallocate(pointer memory, size_type) {
                void* p1 = memory;
                ::operator delete(p1);
            }
            void construct(pointer memory, const Y& value) {
                void* p1 = memory;
                ::new(p1) Y(value);
            }
            void destroy(pointer memory) {
                memory->~Y();
            }
            template<typename U>
            bool operator==(const make_array_helper<T[N], U>& other) const {
                return true;
            }
            template<typename U>
            bool operator!=(const make_array_helper<T[N], U>& other) const {
                return !(*this == other);
            }
        private:
            enum {
                N1 = N * sizeof(T)
            };
            T** data;
        };
    }
}
# 16 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_if_array.hpp" 1 3 4
# 14 "/usr/include/boost/smart_ptr/detail/sp_if_array.hpp" 3 4
namespace boost {
    namespace detail {
        template<typename T>
        struct sp_if_array;
        template<typename T>
        struct sp_if_array<T[]> {
            typedef boost::shared_ptr<T[]> type;
        };
        template<typename T>
        struct sp_if_size_array;
        template<typename T, std::size_t N>
        struct sp_if_size_array<T[N]> {
            typedef boost::shared_ptr<T[N]> type;
        };
    }
}
# 17 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 2 3 4




namespace boost {
    template<typename T>
    inline typename boost::detail::sp_if_array<T>::type
    make_shared(std::size_t size) {
        typedef typename boost::detail::array_inner<T>::type T1;
        typedef typename boost::detail::array_base<T1>::type T2;
        T1* p1 = 0;
        T2* p2 = 0;
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
        boost::detail::make_array_helper<T2[]> a1(n1, &p2);
        boost::detail::array_deleter<T2[]> d1(n1);
        boost::shared_ptr<T> s1(p1, d1, a1);
        typedef boost::detail::array_deleter<T2[]>* D2;
        p1 = reinterpret_cast<T1*>(p2);
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
        d2->init(p2);
        return boost::shared_ptr<T>(s1, p1);
    }
# 209 "/usr/include/boost/smart_ptr/make_shared_array.hpp" 3 4
    template<typename T>
    inline typename boost::detail::sp_if_array<T>::type
    make_shared_noinit(std::size_t size) {
        typedef typename boost::detail::array_inner<T>::type T1;
        typedef typename boost::detail::array_base<T1>::type T2;
        T1* p1 = 0;
        T2* p2 = 0;
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
        boost::detail::make_array_helper<T2[]> a1(n1, &p2);
        boost::detail::array_deleter<T2[]> d1(n1);
        boost::shared_ptr<T> s1(p1, d1, a1);
        typedef boost::detail::array_deleter<T2[]>* D2;
        p1 = reinterpret_cast<T1*>(p2);
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
        d2->noinit(p2);
        return boost::shared_ptr<T>(s1, p1);
    }
    template<typename T>
    inline typename boost::detail::sp_if_size_array<T>::type
    make_shared_noinit() {
        typedef typename boost::detail::array_inner<T>::type T1;
        typedef typename boost::detail::array_base<T1>::type T2;
        enum {
            N = boost::detail::array_total<T>::size
        };
        T1* p1 = 0;
        T2* p2 = 0;
        boost::detail::make_array_helper<T2[N]> a1(&p2);
        boost::detail::array_deleter<T2[N]> d1;
        boost::shared_ptr<T> s1(p1, d1, a1);
        typedef boost::detail::array_deleter<T2[N]>* D2;
        p1 = reinterpret_cast<T1*>(p2);
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
        d2->noinit(p2);
        return boost::shared_ptr<T>(s1, p1);
    }
}
# 19 "/usr/include/boost/smart_ptr/make_shared.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 1 3 4
# 13 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/allocate_array_helper.hpp" 1 3 4
# 14 "/usr/include/boost/smart_ptr/detail/allocate_array_helper.hpp" 3 4
namespace boost {
    namespace detail {
        template<typename A, typename T, typename Y = char>
        class allocate_array_helper;
        template<typename A, typename T, typename Y>
        class allocate_array_helper<A, T[], Y> {
            template<typename A9, typename T9, typename Y9>
            friend class allocate_array_helper;
            typedef typename A::template rebind<Y> ::other A2;
            typedef typename A::template rebind<char>::other A3;
        public:
            typedef typename A2::value_type value_type;
            typedef typename A2::pointer pointer;
            typedef typename A2::const_pointer const_pointer;
            typedef typename A2::reference reference;
            typedef typename A2::const_reference const_reference;
            typedef typename A2::size_type size_type;
            typedef typename A2::difference_type difference_type;
            template<typename U>
            struct rebind {
                typedef allocate_array_helper<A, T[], U> other;
            };
            allocate_array_helper(const A& allocator, std::size_t size, T** data)
                : allocator(allocator),
                  size(sizeof(T) * size),
                  data(data) {
            }
            template<class U>
            allocate_array_helper(const allocate_array_helper<A, T[], U>& other)
                : allocator(other.allocator),
                  size(other.size),
                  data(other.data) {
            }
            pointer address(reference value) const {
                return allocator.address(value);
            }
            const_pointer address(const_reference value) const {
                return allocator.address(value);
            }
            size_type max_size() const {
                return allocator.max_size();
            }
            pointer allocate(size_type count, const void* value = 0) {
                std::size_t a1 = boost::alignment_of<T>::value;
                std::size_t n1 = count * sizeof(Y) + a1 - 1;
                char* p1 = A3(allocator).allocate(n1 + size, value);
                char* p2 = p1 + n1;
                while (std::size_t(p2) % a1 != 0) {
                    p2--;
                }
                *data = reinterpret_cast<T*>(p2);
                return reinterpret_cast<Y*>(p1);
            }
            void deallocate(pointer memory, size_type count) {
                std::size_t a1 = boost::alignment_of<T>::value;
                std::size_t n1 = count * sizeof(Y) + a1 - 1;
                char* p1 = reinterpret_cast<char*>(memory);
                A3(allocator).deallocate(p1, n1 + size);
            }
            void construct(pointer memory, const Y& value) {
                allocator.construct(memory, value);
            }
            void destroy(pointer memory) {
                allocator.destroy(memory);
            }
            template<typename U>
            bool operator==(const allocate_array_helper<A, T[], U>& other) const {
                return allocator == other.allocator;
            }
            template<typename U>
            bool operator!=(const allocate_array_helper<A, T[], U>& other) const {
                return !(*this == other);
            }
        private:
            A2 allocator;
            std::size_t size;
            T** data;
        };
        template<typename A, typename T, std::size_t N, typename Y>
        class allocate_array_helper<A, T[N], Y> {
            template<typename A9, typename T9, typename Y9>
            friend class allocate_array_helper;
            typedef typename A::template rebind<Y> ::other A2;
            typedef typename A::template rebind<char>::other A3;
        public:
            typedef typename A2::value_type value_type;
            typedef typename A2::pointer pointer;
            typedef typename A2::const_pointer const_pointer;
            typedef typename A2::reference reference;
            typedef typename A2::const_reference const_reference;
            typedef typename A2::size_type size_type;
            typedef typename A2::difference_type difference_type;
            template<typename U>
            struct rebind {
                typedef allocate_array_helper<A, T[N], U> other;
            };
            allocate_array_helper(const A& allocator, T** data)
                : allocator(allocator),
                  data(data) {
            }
            template<class U>
            allocate_array_helper(const allocate_array_helper<A, T[N], U>& other)
                : allocator(other.allocator),
                  data(other.data) {
            }
            pointer address(reference value) const {
                return allocator.address(value);
            }
            const_pointer address(const_reference value) const {
                return allocator.address(value);
            }
            size_type max_size() const {
                return allocator.max_size();
            }
            pointer allocate(size_type count, const void* value = 0) {
                std::size_t a1 = boost::alignment_of<T>::value;
                std::size_t n1 = count * sizeof(Y) + a1 - 1;
                char* p1 = A3(allocator).allocate(n1 + N1, value);
                char* p2 = p1 + n1;
                while (std::size_t(p2) % a1 != 0) {
                    p2--;
                }
                *data = reinterpret_cast<T*>(p2);
                return reinterpret_cast<Y*>(p1);
            }
            void deallocate(pointer memory, size_type count) {
                std::size_t a1 = boost::alignment_of<T>::value;
                std::size_t n1 = count * sizeof(Y) + a1 - 1;
                char* p1 = reinterpret_cast<char*>(memory);
                A3(allocator).deallocate(p1, n1 + N1);
            }
            void construct(pointer memory, const Y& value) {
                allocator.construct(memory, value);
            }
            void destroy(pointer memory) {
                allocator.destroy(memory);
            }
            template<typename U>
            bool operator==(const allocate_array_helper<A, T[N], U>& other) const {
                return allocator == other.allocator;
            }
            template<typename U>
            bool operator!=(const allocate_array_helper<A, T[N], U>& other) const {
                return !(*this == other);
            }
        private:
            enum {
                N1 = N * sizeof(T)
            };
            A2 allocator;
            T** data;
        };
    }
}
# 14 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 2 3 4







namespace boost {
    template<typename T, typename A>
    inline typename boost::detail::sp_if_array<T>::type
    allocate_shared(const A& allocator, std::size_t size) {
        typedef typename boost::detail::array_inner<T>::type T1;
        typedef typename boost::detail::array_base<T1>::type T2;
        T1* p1 = 0;
        T2* p2 = 0;
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
        boost::detail::array_deleter<T2[]> d1(n1);
        boost::shared_ptr<T> s1(p1, d1, a1);
        typedef boost::detail::array_deleter<T2[]>* D2;
        p1 = reinterpret_cast<T1*>(p2);
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
        d2->init(p2);
        return boost::shared_ptr<T>(s1, p1);
    }
# 212 "/usr/include/boost/smart_ptr/allocate_shared_array.hpp" 3 4
    template<typename T, typename A>
    inline typename boost::detail::sp_if_array<T>::type
    allocate_shared_noinit(const A& allocator, std::size_t size) {
        typedef typename boost::detail::array_inner<T>::type T1;
        typedef typename boost::detail::array_base<T1>::type T2;
        T1* p1 = 0;
        T2* p2 = 0;
        std::size_t n1 = size * boost::detail::array_total<T1>::size;
        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
        boost::detail::array_deleter<T2[]> d1(n1);
        boost::shared_ptr<T> s1(p1, d1, a1);
        typedef boost::detail::array_deleter<T2[]>* D2;
        p1 = reinterpret_cast<T1*>(p2);
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
        d2->noinit(p2);
        return boost::shared_ptr<T>(s1, p1);
    }
    template<typename T, typename A>
    inline typename boost::detail::sp_if_size_array<T>::type
    allocate_shared_noinit(const A& allocator) {
        typedef typename boost::detail::array_inner<T>::type T1;
        typedef typename boost::detail::array_base<T1>::type T2;
        enum {
            N = boost::detail::array_total<T>::size
        };
        T1* p1 = 0;
        T2* p2 = 0;
        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
        boost::detail::array_deleter<T2[N]> d1;
        boost::shared_ptr<T> s1(p1, d1, a1);
        typedef boost::detail::array_deleter<T2[N]>* D2;
        p1 = reinterpret_cast<T1*>(p2);
        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
        d2->noinit(p2);
        return boost::shared_ptr<T>(s1, p1);
    }
}
# 20 "/usr/include/boost/smart_ptr/make_shared.hpp" 2 3 4
# 16 "/usr/include/boost/make_shared.hpp" 2 3 4
# 25 "./drizzled/session.h" 2
# 1 "/usr/include/boost/scoped_ptr.hpp" 1 3 4
# 14 "/usr/include/boost/scoped_ptr.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 1 3 4
# 15 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 16 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 2 3 4
# 24 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
namespace boost
{
# 41 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
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)
    {
        ((p == 0 || p != px) ? static_cast<void> (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/scoped_ptr.hpp", 87, __PRETTY_FUNCTION__));
        this_type(p).swap(*this);
    }

    T & operator*() const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/scoped_ptr.hpp", 93, __PRETTY_FUNCTION__));
        return *px;
    }

    T * operator->() const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/scoped_ptr.hpp", 99, __PRETTY_FUNCTION__));
        return px;
    }

    T * get() const
    {
        return px;
    }


# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
# 50 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    typedef element_type * this_type::*unspecified_bool_type;

    operator unspecified_bool_type() const
    {
        return px == 0? 0: &this_type::px;
    }




    bool operator! () const
    {
        return px == 0;
    }
# 110 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 2 3 4

    void swap(scoped_ptr & b)
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
};
# 143 "/usr/include/boost/smart_ptr/scoped_ptr.hpp" 3 4
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();
}

}
# 15 "/usr/include/boost/scoped_ptr.hpp" 2 3 4
# 26 "./drizzled/session.h" 2


# 1 "/usr/include/boost/thread/shared_mutex.hpp" 1 3 4
# 21 "/usr/include/boost/thread/shared_mutex.hpp" 3 4
# 1 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 1 3 4
# 11 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 12 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4




# 1 "/usr/include/boost/thread/detail/thread_interruption.hpp" 1 3 4
# 14 "/usr/include/boost/thread/detail/thread_interruption.hpp" 3 4
namespace boost
{
    namespace this_thread
    {
        class __attribute__((visibility("default"))) disable_interruption
        {
          bool interruption_was_enabled;
          friend class restore_interruption;
        public:
            private: disable_interruption(disable_interruption&); public: private: disable_interruption& operator=(disable_interruption&); public:
            disable_interruption() ;
            ~disable_interruption() ;
        };

        class __attribute__((visibility("default"))) restore_interruption
        {
        public:
            private: restore_interruption(restore_interruption&); public: private: restore_interruption& operator=(restore_interruption&); public:
            explicit restore_interruption(disable_interruption& d) ;
            ~restore_interruption() ;
        };
    }
}
# 17 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4







# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 25 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4

namespace boost
{
    class shared_mutex
    {
    private:
        struct state_data
        {
            unsigned shared_count;
            bool exclusive;
            bool upgrade;
            bool exclusive_waiting_blocked;
        };



        state_data state;
        boost::mutex state_change;
        boost::condition_variable shared_cond;
        boost::condition_variable exclusive_cond;
        boost::condition_variable upgrade_cond;

        void release_waiters()
        {
            exclusive_cond.notify_one();
            shared_cond.notify_all();
        }

    public:
        private: shared_mutex(shared_mutex&); public: private: shared_mutex& operator=(shared_mutex&); public:

        shared_mutex()
        {
            state_data state_={0,0,0,0};
            state=state_;
        }

        ~shared_mutex()
        {
        }

        void lock_shared()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);

            while(state.exclusive || state.exclusive_waiting_blocked)
            {
                shared_cond.wait(lk);
            }
            ++state.shared_count;
        }

        bool try_lock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);

            if(state.exclusive || state.exclusive_waiting_blocked)
            {
                return false;
            }
            else
            {
                ++state.shared_count;
                return true;
            }
        }


        bool timed_lock_shared(system_time const& timeout)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);

            while(state.exclusive || state.exclusive_waiting_blocked)
            {
                if(!shared_cond.timed_wait(lk,timeout))
                {
                    return false;
                }
            }
            ++state.shared_count;
            return true;
        }

        template<typename TimeDuration>
        bool timed_lock_shared(TimeDuration const & relative_time)
        {
            return timed_lock_shared(get_system_time()+relative_time);
        }


        template <class Rep, class Period>
        bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_shared_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);

          while(state.exclusive || state.exclusive_waiting_blocked)
          {
              if(cv_status::timeout==shared_cond.wait_until(lk,abs_time))
              {
                  return false;
              }
          }
          ++state.shared_count;
          return true;
        }

        void unlock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            bool const last_reader=!--state.shared_count;

            if(last_reader)
            {
                if(state.upgrade)
                {
                    state.upgrade=false;
                    state.exclusive=true;
                    upgrade_cond.notify_one();
                }
                else
                {
                    state.exclusive_waiting_blocked=false;
                }
                release_waiters();
            }
        }

        void lock()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);

            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
                exclusive_cond.wait(lk);
            }
            state.exclusive=true;
        }


        bool timed_lock(system_time const& timeout)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);

            while(state.shared_count || state.exclusive)
            {
                state.exclusive_waiting_blocked=true;
                if(!exclusive_cond.timed_wait(lk,timeout))
                {
                    if(state.shared_count || state.exclusive)
                    {
                        state.exclusive_waiting_blocked=false;
                        release_waiters();
                        return false;
                    }
                    break;
                }
            }
            state.exclusive=true;
            return true;
        }

        template<typename TimeDuration>
        bool timed_lock(TimeDuration const & relative_time)
        {
            return timed_lock(get_system_time()+relative_time);
        }


        template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);

          while(state.shared_count || state.exclusive)
          {
              state.exclusive_waiting_blocked=true;
              if(cv_status::timeout == exclusive_cond.wait_until(lk,abs_time))
              {
                  if(state.shared_count || state.exclusive)
                  {
                      state.exclusive_waiting_blocked=false;
                      release_waiters();
                      return false;
                  }
                  break;
              }
          }
          state.exclusive=true;
          return true;
        }


        bool try_lock()
        {
            boost::unique_lock<boost::mutex> lk(state_change);

            if(state.shared_count || state.exclusive)
            {
                return false;
            }
            else
            {
                state.exclusive=true;
                return true;
            }

        }

        void unlock()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.exclusive=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }

        void lock_upgrade()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
                shared_cond.wait(lk);
            }
            ++state.shared_count;
            state.upgrade=true;
        }


        bool timed_lock_upgrade(system_time const& timeout)
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
                if(!shared_cond.timed_wait(lk,timeout))
                {
                    if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
                    {
                        return false;
                    }
                    break;
                }
            }
            ++state.shared_count;
            state.upgrade=true;
            return true;
        }

        template<typename TimeDuration>
        bool timed_lock_upgrade(TimeDuration const & relative_time)
        {
            return timed_lock_upgrade(get_system_time()+relative_time);
        }


        template <class Rep, class Period>
        bool try_lock_upgrade_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_upgrade_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_upgrade_until(const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);
          while(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
          {
              if(cv_status::timeout == shared_cond.wait_until(lk,abs_time))
              {
                  if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
                  {
                      return false;
                  }
                  break;
              }
          }
          ++state.shared_count;
          state.upgrade=true;
          return true;
        }

        bool try_lock_upgrade()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            if(state.exclusive || state.exclusive_waiting_blocked || state.upgrade)
            {
                return false;
            }
            else
            {
                ++state.shared_count;
                state.upgrade=true;
                return true;
            }
        }

        void unlock_upgrade()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.upgrade=false;
            bool const last_reader=!--state.shared_count;

            if(last_reader)
            {
                state.exclusive_waiting_blocked=false;
                release_waiters();
            } else {
              shared_cond.notify_all();
            }
        }


        void unlock_upgrade_and_lock()
        {

            boost::this_thread::disable_interruption do_not_disturb;

            boost::unique_lock<boost::mutex> lk(state_change);
            --state.shared_count;
            while(state.shared_count)
            {
                upgrade_cond.wait(lk);
            }
            state.upgrade=false;
            state.exclusive=true;
        }

        void unlock_and_lock_upgrade()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.exclusive=false;
            state.upgrade=true;
            ++state.shared_count;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }

        bool try_unlock_upgrade_and_lock()
        {
          boost::unique_lock<boost::mutex> lk(state_change);
          if( !state.exclusive
              && !state.exclusive_waiting_blocked
              && state.upgrade
              && state.shared_count==1)
          {
            state.shared_count=0;
            state.exclusive=true;
            state.upgrade=false;
            return true;
          }
          return false;
        }

        template <class Rep, class Period>
        bool
        try_unlock_upgrade_and_lock_for(
                                const chrono::duration<Rep, Period>& rel_time)
        {
          return try_unlock_upgrade_and_lock_until(
                                 chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool
        try_unlock_upgrade_and_lock_until(
                          const chrono::time_point<Clock, Duration>& abs_time)
        {

          boost::this_thread::disable_interruption do_not_disturb;

          boost::unique_lock<boost::mutex> lk(state_change);
          if (state.shared_count != 1)
          {
              for (;;)
              {
                cv_status status = shared_cond.wait_until(lk,abs_time);
                if (state.shared_count == 1)
                  break;
                if(status == cv_status::timeout)
                  return false;
              }
          }
          state.upgrade=false;
          state.exclusive=true;
          state.exclusive_waiting_blocked=false;
          state.shared_count=0;
          return true;
        }



        void unlock_and_lock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.exclusive=false;
            ++state.shared_count;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
# 514 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
        void unlock_upgrade_and_lock_shared()
        {
            boost::unique_lock<boost::mutex> lk(state_change);
            state.upgrade=false;
            state.exclusive_waiting_blocked=false;
            release_waiters();
        }
# 576 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 3 4
    };

    typedef shared_mutex upgrade_mutex;
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 582 "/usr/include/boost/thread/pthread/shared_mutex.hpp" 2 3 4
# 22 "/usr/include/boost/thread/shared_mutex.hpp" 2 3 4






namespace boost
{
  namespace sync
  {
# 45 "/usr/include/boost/thread/shared_mutex.hpp" 3 4
  }
}
# 29 "./drizzled/session.h" 2
# 1 "/usr/include/boost/thread/thread.hpp" 1 3 4
# 22 "/usr/include/boost/thread/thread.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/thread.hpp" 1 3 4
# 21 "/usr/include/boost/thread/detail/thread.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/make_tuple_indices.hpp" 1 3 4
# 22 "/usr/include/boost/thread/detail/make_tuple_indices.hpp" 3 4
namespace boost
{
  namespace detail
  {
# 57 "/usr/include/boost/thread/detail/make_tuple_indices.hpp" 3 4
  }
}
# 22 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
# 1 "/usr/include/boost/thread/detail/invoke.hpp" 1 3 4
# 22 "/usr/include/boost/thread/detail/invoke.hpp" 3 4
namespace boost
{
  namespace detail
  {
# 85 "/usr/include/boost/thread/detail/invoke.hpp" 3 4
      }
    }
# 23 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
# 1 "/usr/include/boost/thread/detail/is_convertible.hpp" 1 3 4
# 17 "/usr/include/boost/thread/detail/is_convertible.hpp" 3 4
namespace boost
{
  namespace thread_detail
  {
    template <typename T1, typename T2>
    struct is_convertible : boost::is_convertible<T1,T2> {};
# 43 "/usr/include/boost/thread/detail/is_convertible.hpp" 3 4
  }

}
# 24 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 25 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4



# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 29 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
# 1 "/usr/include/boost/bind.hpp" 1 3 4
# 22 "/usr/include/boost/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/bind.hpp" 1 3 4
# 28 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/is_placeholder.hpp" 1 3 4
# 21 "/usr/include/boost/is_placeholder.hpp" 3 4
namespace boost
{

template< class T > struct is_placeholder
{
    enum _vt { value = 0 };
};

}
# 29 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/bind/arg.hpp" 1 3 4
# 25 "/usr/include/boost/bind/arg.hpp" 3 4
namespace boost
{

template< int I > struct arg
{
    arg()
    {
    }

    template< class T > arg( T const & )
    {

        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
    }
};

template< int I > bool operator==( arg<I> const &, arg<I> const & )
{
    return true;
}



template< int I > struct is_placeholder< arg<I> >
{
    enum _vt { value = I };
};

template< int I > struct is_placeholder< arg<I> (*) () >
{
    enum _vt { value = I };
};



}
# 30 "/usr/include/boost/bind/bind.hpp" 2 3 4

# 1 "/usr/include/boost/visit_each.hpp" 1 3 4
# 15 "/usr/include/boost/visit_each.hpp" 3 4
namespace boost {
  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t, long)
  {
    visitor(t);
  }

  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t)
  {
    visit_each(visitor, t, 0);
  }
}
# 32 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 41 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/storage.hpp" 1 3 4
# 32 "/usr/include/boost/bind/storage.hpp" 3 4
namespace boost
{

namespace _bi
{



template<class A1> struct storage1
{
    explicit storage1( A1 a1 ): a1_( a1 ) {}

    template<class V> void accept(V & v) const
    {
        visit_each(v, a1_, 0);
    }

    A1 a1_;
};



template<int I> struct storage1< boost::arg<I> >
{
    explicit storage1( boost::arg<I> ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};

template<int I> struct storage1< boost::arg<I> (*) () >
{
    explicit storage1( boost::arg<I> (*) () ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};





template<class A1, class A2> struct storage2: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a2_, 0);
    }

    A2 a2_;
};



template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};

template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a3_, 0);
    }

    A3 a3_;
};



template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};

template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a4_, 0);
    }

    A4 a4_;
};



template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a5_, 0);
    }

    A5 a5_;
};



template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a6_, 0);
    }

    A6 a6_;
};



template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a7_, 0);
    }

    A7 a7_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a8_, 0);
    }

    A8 a8_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a9_, 0);
    }

    A9 a9_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};



}

}
# 42 "/usr/include/boost/bind/bind.hpp" 2 3 4






namespace boost
{

template<class T> class weak_ptr;

namespace _bi
{



template<class R, class F> struct result_traits
{
    typedef R type;
};



struct unspecified {};

template<class F> struct result_traits<unspecified, F>
{
    typedef typename F::result_type type;
};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >
{
    typedef typename F::result_type type;
};





template<class T> bool ref_compare( T const & a, T const & b, long )
{
    return a == b;
}

template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
{
    return true;
}

template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
{
    return true;
}

template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
{
    return a.get_pointer() == b.get_pointer();
}



template<class R, class F, class L> class bind_t;

template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
{
    return a.compare( b );
}



template<class T> class value
{
public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }
    T const & get() const { return t_; }

    bool operator==(value const & rhs) const
    {
        return t_ == rhs.t_;
    }

private:

    T t_;
};



template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
{
    return !(a.get() < b.get()) && !(b.get() < a.get());
}



template<class T> class type {};



template<class F> struct unwrapper
{
    static inline F & unwrap( F & f, long )
    {
        return f;
    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
    {
        return rf.get();
    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
    {
        return _mfi::dm<R, T>( pm );
    }
};



class list0
{
public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
    {
        return unwrapper<F>::unwrap(f, 0)();
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)
    {
        unwrapper<F>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
    {
        unwrapper<F const>::unwrap(f, 0)();
    }

    template<class V> void accept(V &) const
    {
    }

    bool operator==(list0 const &) const
    {
        return true;
    }
};
# 217 "/usr/include/boost/bind/bind.hpp" 3 4
template< class A1 > class list1: private storage1< A1 >
{
private:

    typedef storage1< A1 > base_type;

public:

    explicit list1( A1 a1 ): base_type( a1 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }

    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }

    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list1 const & rhs) const
    {
        return ref_compare(base_type::a1_, rhs.a1_, 0);
    }
};

struct logical_and;
struct logical_or;

template< class A1, class A2 > class list2: private storage2< A1, A2 >
{
private:

    typedef storage2< A1, A2 > base_type;

public:

    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
    }

    template<class A> bool operator()( type<bool>, logical_and & , A & a, int )
    {
        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_and const & , A & a, int ) const
    {
        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_or & , A & a, int )
    {
        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
    }

    template<class A> bool operator()( type<bool>, logical_or const & , A & a, int ) const
    {
        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list2 const & rhs) const
    {
        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
    }
};

template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
{
private:

    typedef storage3< A1, A2, A3 > base_type;

public:

    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list3 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 );
    }
};

template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
{
private:

    typedef storage4< A1, A2, A3, A4 > base_type;

public:

    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list4 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 );
    }
};

template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
{
private:

    typedef storage5< A1, A2, A3, A4, A5 > base_type;

public:

    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list5 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
{
private:

    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;

public:

    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list6 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
{
private:

    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;

public:

    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list7 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 );
    }
};

template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
private:

    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;

public:

    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list8 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
            ref_compare( base_type::a8_, rhs.a8_, 0 );
    }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
{
private:

    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;

public:

    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}

    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }

    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
    {
        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
    {
        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
    {
        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
    }

    template<class V> void accept(V & v) const
    {
        base_type::accept(v);
    }

    bool operator==(list9 const & rhs) const
    {
        return

            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
            ref_compare( base_type::a9_, rhs.a9_, 0 );
    }
};
# 864 "/usr/include/boost/bind/bind.hpp" 3 4
template<class R, class F, class L> class bind_t
{
public:

    typedef bind_t this_type;

    bind_t(F f, L const & l): f_(f), l_(l) {}


# 1 "/usr/include/boost/bind/bind_template.hpp" 1 3 4
# 15 "/usr/include/boost/bind/bind_template.hpp" 3 4
    typedef typename result_traits<R, F>::type result_type;

    result_type operator()()
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1> result_type operator()(A1 const & a1)
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 const & a1) const
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(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
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(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)
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(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
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A> result_type eval(A & a)
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
    {


        using boost::visit_each;


        visit_each(v, f_, 0);
        l_.accept(v);
    }

    bool compare(this_type const & rhs) const
    {
        return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
    }

private:

    F f_;
    L l_;
# 874 "/usr/include/boost/bind/bind.hpp" 2 3 4


};
# 940 "/usr/include/boost/bind/bind.hpp" 3 4
template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
{
    return a.compare(b);
}
# 994 "/usr/include/boost/bind/bind.hpp" 3 4
template< class T, int I > struct add_value_2
{
    typedef boost::arg<I> type;
};

template< class T > struct add_value_2< T, 0 >
{
    typedef _bi::value< T > type;
};

template<class T> struct add_value
{
    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
};



template<class T> struct add_value< value<T> >
{
    typedef _bi::value<T> type;
};

template<class T> struct add_value< reference_wrapper<T> >
{
    typedef reference_wrapper<T> type;
};

template<int I> struct add_value< arg<I> >
{
    typedef boost::arg<I> type;
};

template<int I> struct add_value< arg<I> (*) () >
{
    typedef boost::arg<I> (*type) ();
};

template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
{
    typedef bind_t<R, F, L> type;
};
# 1077 "/usr/include/boost/bind/bind.hpp" 3 4
template<class A1> struct list_av_1
{
    typedef typename add_value<A1>::type B1;
    typedef list1<B1> type;
};

template<class A1, class A2> struct list_av_2
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef list2<B1, B2> type;
};

template<class A1, class A2, class A3> struct list_av_3
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef list3<B1, B2, B3> type;
};

template<class A1, class A2, class A3, class A4> struct list_av_4
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef list4<B1, B2, B3, B4> type;
};

template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef list5<B1, B2, B3, B4, B5> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef list6<B1, B2, B3, B4, B5, B6> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef typename add_value<A9>::type B9;
    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
};



struct logical_not
{
    template<class V> bool operator()(V const & v) const { return !v; }
};

template<class R, class F, class L>
    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
    operator! (bind_t<R, F, L> const & f)
{
    typedef list1< bind_t<R, F, L> > list_type;
    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
}
# 1200 "/usr/include/boost/bind/bind.hpp" 3 4
struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }

struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }

struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }

struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
# 1240 "/usr/include/boost/bind/bind.hpp" 3 4
template<class V, class T> void visit_each( V & v, value<T> const & t, int )
{
    using boost::visit_each;
    visit_each( v, t.get(), 0 );
}

template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
{
    t.accept( v );
}



}
# 1274 "/usr/include/boost/bind/bind.hpp" 3 4
template< class T > struct is_bind_expression
{
    enum _vt { value = 0 };
};



template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
{
    enum _vt { value = 1 };
};
# 1296 "/usr/include/boost/bind/bind.hpp" 3 4
template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}



template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(boost::type<R>, F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(boost::type<R>, F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}





template<class F>
    _bi::bind_t<_bi::unspecified, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
}

template<class F, class A1>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
}

template<class F, class A1, class A2>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
}

template<class F, class A1, class A2, class A3>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
}

template<class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1549 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/bind_cc.hpp" 1 3 4
# 15 "/usr/include/boost/bind/bind_cc.hpp" 3 4
template<class R>
    _bi::bind_t<R, R ( *) (), _bi::list0>
    bind( R ( *f) ())
{
    typedef R ( *F) ();
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class B1, class A1>
    _bi::bind_t<R, R ( *) (B1), typename _bi::list_av_1<A1>::type>
    bind( R ( *f) (B1), A1 a1)
{
    typedef R ( *F) (B1);
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class B1, class B2, class A1, class A2>
    _bi::bind_t<R, R ( *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
    bind( R ( *f) (B1, B2), A1 a1, A2 a2)
{
    typedef R ( *F) (B1, B2);
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R,
    class B1, class B2, class B3,
    class A1, class A2, class A3>
    _bi::bind_t<R, R ( *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
    bind( R ( *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
{
    typedef R ( *F) (B1, B2, B3);
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind( R ( *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef R ( *F) (B1, B2, B3, B4);
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef R ( *F) (B1, B2, B3, B4, B5);
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6);
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7);
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8);
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1550 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1595 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/bind_mf_cc.hpp" 1 3 4
# 17 "/usr/include/boost/bind/bind_mf_cc.hpp" 3 4
template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}



template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}



template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1596 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/bind/bind_mf2_cc.hpp" 1 3 4
# 18 "/usr/include/boost/bind/bind_mf2_cc.hpp" 3 4
template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1597 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1656 "/usr/include/boost/bind/bind.hpp" 3 4
namespace _bi
{

template< class Pm, int I > struct add_cref;

template< class M, class T > struct add_cref< M T::*, 0 >
{
    typedef M type;
};

template< class M, class T > struct add_cref< M T::*, 1 >
{




    typedef M const & type;



};

template< class R, class T > struct add_cref< R (T::*) (), 1 >
{
    typedef void type;
};



template< class R, class T > struct add_cref< R (T::*) () const, 1 >
{
    typedef void type;
};



template<class R> struct isref
{
    enum value_type { value = 0 };
};

template<class R> struct isref< R& >
{
    enum value_type { value = 1 };
};

template<class R> struct isref< R* >
{
    enum value_type { value = 1 };
};

template<class Pm, class A1> struct dm_result
{
    typedef typename add_cref< Pm, 1 >::type type;
};

template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
{
    typedef typename bind_t<R, F, L>::result_type result_type;
    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
};

}

template< class A1, class M, class T >

_bi::bind_t<
    typename _bi::dm_result< M T::*, A1 >::type,
    _mfi::dm<M, T>,
    typename _bi::list_av_1<A1>::type
>

bind( M T::*f, A1 a1 )
{
    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
    typedef _mfi::dm<M, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
}



}



# 1 "/usr/include/boost/bind/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/bind/placeholders.hpp" 3 4
namespace
{
# 55 "/usr/include/boost/bind/placeholders.hpp" 3 4
boost::arg<1> _1;
boost::arg<2> _2;
boost::arg<3> _3;
boost::arg<4> _4;
boost::arg<5> _5;
boost::arg<6> _6;
boost::arg<7> _7;
boost::arg<8> _8;
boost::arg<9> _9;



}
# 1743 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 23 "/usr/include/boost/bind.hpp" 2 3 4
# 30 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4







# 1 "/usr/include/boost/functional/hash.hpp" 1 3 4





# 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
# 7 "/usr/include/boost/functional/hash.hpp" 2 3 4
# 38 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
# 46 "/usr/include/boost/thread/detail/thread.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 47 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4






namespace boost
{

    namespace detail
    {
# 90 "/usr/include/boost/thread/detail/thread.hpp" 3 4
        template<typename F>
        class thread_data:
            public detail::thread_data_base
        {
        public:
            private: thread_data(thread_data&); public: private: thread_data& operator=(thread_data&); public:
# 106 "/usr/include/boost/thread/detail/thread.hpp" 3 4
            thread_data(boost::detail::thread_move_t< F > f_):
              f(f_)
            {}
            thread_data(F f_):
                f(f_)
            {}



            void run()
            {
                f();
            }

        private:
            F f;
        };

        template<typename F>
        class thread_data<boost::reference_wrapper<F> >:
            public detail::thread_data_base
        {
        private:
            F& f;
        public:
            private: thread_data(thread_data&); public: private: thread_data& operator=(thread_data&); public:
            thread_data(boost::reference_wrapper<F> f_):
                f(f_)
            {}
            void run()
            {
                f();
            }
        };

        template<typename F>
        class thread_data<const boost::reference_wrapper<F> >:
            public detail::thread_data_base
        {
        private:
            F& f;
        public:
            private: thread_data(thread_data&); public: private: thread_data& operator=(thread_data&); public:
            thread_data(const boost::reference_wrapper<F> f_):
                f(f_)
            {}
            void run()
            {
                f();
            }
        };

    }

    class __attribute__((visibility("default"))) thread
    {
    public:
      typedef thread_attributes attributes;

      private: thread(thread&); public: private: thread& operator=(thread&); public: operator ::boost::detail::thread_move_t<thread>() { return move(); } ::boost::detail::thread_move_t<thread> move() { ::boost::detail::thread_move_t<thread> x(*this); return x; }
    private:

        struct dummy;

        void release_handle();

        detail::thread_data_ptr thread_info;

    private:
        bool start_thread_noexcept();
        bool start_thread_noexcept(const attributes& attr);
    public:
        void start_thread()
        {
          if (!start_thread_noexcept())
          {
            boost::throw_exception(thread_resource_error());
          }
        }
        void start_thread(const attributes& attr)
        {
          if (!start_thread_noexcept(attr))
          {
            boost::throw_exception(thread_resource_error());
          }
        }

        explicit thread(detail::thread_data_ptr data);

        detail::thread_data_ptr get_thread_info () const;
# 223 "/usr/include/boost/thread/detail/thread.hpp" 3 4
        template<typename F>
        static inline detail::thread_data_ptr make_thread_info(F f
            , typename disable_if_c<

                is_same<typename decay<F>::type, thread>::value,
                dummy* >::type=0
                )
        {
            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
        }
        template<typename F>
        static inline detail::thread_data_ptr make_thread_info(boost::detail::thread_move_t< F > f)
        {
            return detail::thread_data_ptr(detail::heap_new<detail::thread_data<F> >(f));
        }


    public:





        thread() ;
        ~thread()
        {






            detach();

        }
# 293 "/usr/include/boost/thread/detail/thread.hpp" 3 4
        template <class F>
        explicit thread(F f
        , typename disable_if_c<
            boost::thread_detail::is_convertible<F&,boost::detail::thread_move_t< F > >::value

           , dummy* >::type=0
        ):
            thread_info(make_thread_info(f))
        {
            start_thread();
        }
        template <class F>
        thread(attributes const& attrs, F f
        , typename disable_if<boost::thread_detail::is_convertible<F&,boost::detail::thread_move_t< F > >, dummy* >::type=0
        ):
            thread_info(make_thread_info(f))
        {
            start_thread(attrs);
        }

        template <class F>
        explicit thread(boost::detail::thread_move_t< F > f
        , typename disable_if<is_same<typename decay<F>::type, thread>, dummy* >::type=0
        ):



        thread_info(make_thread_info(f))

        {
            start_thread();
        }

        template <class F>
        thread(attributes const& attrs, boost::detail::thread_move_t< F > f):



            thread_info(make_thread_info(f))

        {
            start_thread(attrs);
        }

        thread(boost::detail::thread_move_t< thread > x)
        {
            thread_info=(*x).thread_info;
            (*x).thread_info.reset();
        }
# 352 "/usr/include/boost/thread/detail/thread.hpp" 3 4
        thread& operator=(boost::detail::thread_move_t< thread > other)
        {




            thread_info=(*other).thread_info;
            (*other).thread_info.reset();
            return *this;
        }
# 387 "/usr/include/boost/thread/detail/thread.hpp" 3 4
        template <class F,class A1>
        thread(F f,A1 a1,typename disable_if<boost::thread_detail::is_convertible<F&,thread_attributes >, dummy* >::type=0):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
        {
            start_thread();
        }
        template <class F,class A1,class A2>
        thread(F f,A1 a1,A2 a2):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3>
        thread(F f,A1 a1,A2 a2,A3 a3):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3,class A4>
        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3,class A4,class A5>
        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
        {
            start_thread();
        }

        template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
        thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
            thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
        {
            start_thread();
        }

        void swap(thread& x)
        {
            thread_info.swap(x.thread_info);
        }

        class id;

        inline id get_id() const ;





        bool joinable() const ;
    private:
        bool join_noexcept();
    public:
        inline void join();


        template <class Rep, class Period>
        bool try_join_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_join_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_join_until(const chrono::time_point<Clock, Duration>& t)
        {
          using namespace chrono;
          system_clock::time_point s_now = system_clock::now();
          typename Clock::time_point c_now = Clock::now();
          return try_join_until(s_now + ceil<nanoseconds>(t - c_now));
        }
        template <class Duration>
        bool try_join_until(const chrono::time_point<chrono::system_clock, Duration>& t)
        {
          using namespace chrono;
          typedef time_point<system_clock, nanoseconds> nano_sys_tmpt;
          return try_join_until(nano_sys_tmpt(ceil<nanoseconds>(t.time_since_epoch())));
        }
# 510 "/usr/include/boost/thread/detail/thread.hpp" 3 4
    private:
        bool do_try_join_until_noexcept(struct timespec const &timeout, bool& res);
        inline bool do_try_join_until(struct timespec const &timeout);
    public:

        bool timed_join(const system_time& abs_time)
        {
          struct timespec const ts=detail::to_timespec(abs_time);
          return do_try_join_until(ts);
        }


        bool try_join_until(const chrono::time_point<chrono::system_clock, chrono::nanoseconds>& tp)
        {
          using namespace chrono;
          nanoseconds d = tp.time_since_epoch();
          timespec ts = boost::detail::to_timespec(d);
          return do_try_join_until(ts);
        }



      public:


        template<typename TimeDuration>
        inline bool timed_join(TimeDuration const& rel_time)
        {
            return timed_join(get_system_time()+rel_time);
        }

        void detach();

        static unsigned hardware_concurrency() ;


        typedef detail::thread_data_base::native_handle_type native_handle_type;
        native_handle_type native_handle();




        bool operator==(const thread& other) const;
        bool operator!=(const thread& other) const;


        static inline void yield()
        {
            this_thread::yield();
        }

        static inline void sleep(const system_time& xt)
        {
            this_thread::sleep(xt);
        }




        void interrupt();
        bool interruption_requested() const ;

    };

    inline void swap(thread& lhs,thread& rhs)
    {
        return lhs.swap(rhs);
    }
# 586 "/usr/include/boost/thread/detail/thread.hpp" 3 4
    template <> struct enable_move_utility_emulation< thread > { static const bool value = false; };

    namespace this_thread
    {

        inline thread::id get_id() ;





        void __attribute__((visibility("default"))) interruption_point();
        bool __attribute__((visibility("default"))) interruption_enabled() ;
        bool __attribute__((visibility("default"))) interruption_requested() ;



        inline __attribute__((visibility("default"))) void sleep(xtime const& abs_time)
        {
            sleep(system_time(abs_time));
        }

    }

    class __attribute__((visibility("default"))) thread::id
    {
    private:
        friend inline
        std::size_t
        hash_value(const thread::id &v)
        {

          return hash_value(v.thread_data);



        }





        typedef thread::native_handle_type data;




        data thread_data;

        id(data thread_data_):
            thread_data(thread_data_)
        {}
        friend class thread;
        friend id __attribute__((visibility("default"))) this_thread::get_id() ;
    public:
        id() :

        thread_data(0)



        {}

        id(const id& other) :
            thread_data(other.thread_data)
        {}

        bool operator==(const id& y) const
        {
            return thread_data==y.thread_data;
        }

        bool operator!=(const id& y) const
        {
            return thread_data!=y.thread_data;
        }

        bool operator<(const id& y) const
        {
            return thread_data<y.thread_data;
        }

        bool operator>(const id& y) const
        {
            return y.thread_data<thread_data;
        }

        bool operator<=(const id& y) const
        {
            return !(y.thread_data<thread_data);
        }

        bool operator>=(const id& y) const
        {
            return !(thread_data<y.thread_data);
        }



        template<class charT, class traits>
        friend __attribute__((visibility("default")))
  std::basic_ostream<charT, traits>&
        operator<<(std::basic_ostream<charT, traits>& os, const id& x)
        {
            if(x.thread_data)
            {
                io::ios_flags_saver ifs( os );
                return os<< std::hex << x.thread_data;
            }
            else
            {
                return os<<"{Not-any-thread}";
            }
        }
# 719 "/usr/include/boost/thread/detail/thread.hpp" 3 4
    };


    thread::id thread::get_id() const
    {

        return const_cast<thread*>(this)->native_handle();




    }

    namespace this_thread
    {
        inline thread::id get_id()
        {

             return pthread_self();




        }
    }

    void thread::join() {
        if (this_thread::get_id() == get_id())
          boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));

        (void)(join_noexcept())

         ;
    }


    bool thread::do_try_join_until(struct timespec const &timeout)



    {
        if (this_thread::get_id() == get_id())
          boost::throw_exception(thread_resource_error(system::errc::resource_deadlock_would_occur, "boost thread: trying joining itself"));
        bool res;
        if (do_try_join_until_noexcept(timeout, res))
        {
          return res;
        }
        else
        {
          return (false)


           ;
        }
    }
# 787 "/usr/include/boost/thread/detail/thread.hpp" 3 4
    inline bool thread::operator==(const thread& other) const
    {
        return get_id()==other.get_id();
    }

    inline bool thread::operator!=(const thread& other) const
    {
        return get_id()!=other.get_id();
    }


    namespace detail
    {
        struct thread_exit_function_base
        {
            virtual ~thread_exit_function_base()
            {}
            virtual void operator()()=0;
        };

        template<typename F>
        struct thread_exit_function:
            thread_exit_function_base
        {
            F f;

            thread_exit_function(F f_):
                f(f_)
            {}

            void operator()()
            {
                f();
            }
        };

        void __attribute__((visibility("default"))) add_thread_exit_function(thread_exit_function_base*);
    }

    namespace this_thread
    {
        template<typename F>
        void at_thread_exit(F f)
        {
            detail::thread_exit_function_base* const thread_exit_func=detail::heap_new<detail::thread_exit_function<F> >(f);
            detail::add_thread_exit_function(thread_exit_func);
        }
    }
}





# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 842 "/usr/include/boost/thread/detail/thread.hpp" 2 3 4
# 23 "/usr/include/boost/thread/thread.hpp" 2 3 4



# 1 "/usr/include/boost/thread/detail/thread_group.hpp" 1 3 4
# 13 "/usr/include/boost/thread/detail/thread_group.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 14 "/usr/include/boost/thread/detail/thread_group.hpp" 2 3 4






namespace boost
{
    class thread_group
    {
    private:
        thread_group(thread_group const&);
        thread_group& operator=(thread_group const&);
    public:
        thread_group() {}
        ~thread_group()
        {
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
                delete *it;
            }
        }

        bool is_this_thread_in()
        {
            thread::id id = this_thread::get_id();
            boost::shared_lock<shared_mutex> guard(m);
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
              if ((*it)->get_id() == id)
                return true;
            }
            return false;
        }

        bool is_thread_in(thread* thrd)
        {
          if(thrd)
          {
            thread::id id = thrd->get_id();
            boost::shared_lock<shared_mutex> guard(m);
            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
              if ((*it)->get_id() == id)
                return true;
            }
            return false;
          }
          else
          {
            return false;
          }
        }

        template<typename F>
        thread* create_thread(F threadfunc)
        {
            boost::lock_guard<shared_mutex> guard(m);
            std::auto_ptr<thread> new_thread(new thread(threadfunc));
            threads.push_back(new_thread.get());
            return new_thread.release();
        }

        void add_thread(thread* thrd)
        {
            if(thrd)
            {
               

                 ;

                boost::lock_guard<shared_mutex> guard(m);
                threads.push_back(thrd);
            }
        }

        void remove_thread(thread* thrd)
        {
            boost::lock_guard<shared_mutex> guard(m);
            std::list<thread*>::iterator const it=std::find(threads.begin(),threads.end(),thrd);
            if(it!=threads.end())
            {
                threads.erase(it);
            }
        }

        void join_all()
        {
           

             ;
            boost::shared_lock<shared_mutex> guard(m);

            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
              if ((*it)->joinable())
                (*it)->join();
            }
        }


        void interrupt_all()
        {
            boost::shared_lock<shared_mutex> guard(m);

            for(std::list<thread*>::iterator it=threads.begin(),end=threads.end();
                it!=end;
                ++it)
            {
                (*it)->interrupt();
            }
        }


        size_t size() const
        {
            boost::shared_lock<shared_mutex> guard(m);
            return threads.size();
        }

    private:
        std::list<thread*> threads;
        mutable shared_mutex m;
    };
}





# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 153 "/usr/include/boost/thread/detail/thread_group.hpp" 2 3 4
# 27 "/usr/include/boost/thread/thread.hpp" 2 3 4
# 1 "/usr/include/boost/thread/v2/thread.hpp" 1 3 4
# 17 "/usr/include/boost/thread/v2/thread.hpp" 3 4
namespace boost
{
  namespace this_thread
  {



    template <class Clock, class Duration>
    void sleep_until(const chrono::time_point<Clock, Duration>& t)
    {
      using namespace chrono;
      mutex mut;
      condition_variable cv;
      unique_lock<mutex> lk(mut);
      while (Clock::now() < t)
        cv.wait_until(lk, t);
    }



    template <class Rep, class Period>
    void sleep_for(const chrono::duration<Rep, Period>& d)
    {
      using namespace chrono;
      if (d > duration<Rep, Period>::zero())
      {
          duration<long double> Max = nanoseconds::max ();
          nanoseconds ns;
          if (d < Max)
          {
              ns = duration_cast<nanoseconds>(d);
              if (ns < d)
                  ++ns;
          }
          else
              ns = nanoseconds:: max ();
          sleep_for(ns);
      }
    }

    template <class Duration>
    inline __attribute__((visibility("default")))
    void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
    {
      using namespace chrono;
      sleep_for(t - steady_clock::now());
    }
# 82 "/usr/include/boost/thread/v2/thread.hpp" 3 4
  }
}
# 28 "/usr/include/boost/thread/thread.hpp" 2 3 4
# 30 "./drizzled/session.h" 2

# 1 "/usr/include/netdb.h" 1 3 4
# 27 "/usr/include/netdb.h" 3 4
# 1 "/usr/include/netinet/in.h" 1 3 4
# 24 "/usr/include/netinet/in.h" 3 4
# 1 "/usr/include/i386-linux-gnu/sys/socket.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/sys/socket.h" 3 4
extern "C" {

# 1 "/usr/include/i386-linux-gnu/sys/uio.h" 1 3 4
# 26 "/usr/include/i386-linux-gnu/sys/uio.h" 3 4
extern "C" {


# 1 "/usr/include/i386-linux-gnu/bits/uio.h" 1 3 4
# 43 "/usr/include/i386-linux-gnu/bits/uio.h" 3 4
struct iovec
  {
    void *iov_base;
    size_t iov_len;
  };
# 56 "/usr/include/i386-linux-gnu/bits/uio.h" 3 4
extern "C" {


extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
     unsigned long int __liovcnt,
     const struct iovec *__rvec,
     unsigned long int __riovcnt,
     unsigned long int __flags)
  throw ();


extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
      unsigned long int __liovcnt,
      const struct iovec *__rvec,
      unsigned long int __riovcnt,
      unsigned long int __flags)
  throw ();

}
# 30 "/usr/include/i386-linux-gnu/sys/uio.h" 2 3 4
# 40 "/usr/include/i386-linux-gnu/sys/uio.h" 3 4
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
  __attribute__ ((__warn_unused_result__));
# 51 "/usr/include/i386-linux-gnu/sys/uio.h" 3 4
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
  __attribute__ ((__warn_unused_result__));
# 82 "/usr/include/i386-linux-gnu/sys/uio.h" 3 4
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "preadv64")

                __attribute__ ((__warn_unused_result__));
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count, __off64_t __offset) __asm__ ("" "pwritev64")

                 __attribute__ ((__warn_unused_result__));
# 104 "/usr/include/i386-linux-gnu/sys/uio.h" 3 4
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
    __off64_t __offset) __attribute__ ((__warn_unused_result__));
# 116 "/usr/include/i386-linux-gnu/sys/uio.h" 3 4
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
     __off64_t __offset) __attribute__ ((__warn_unused_result__));



}
# 28 "/usr/include/i386-linux-gnu/sys/socket.h" 2 3 4

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 30 "/usr/include/i386-linux-gnu/sys/socket.h" 2 3 4


# 1 "/usr/include/i386-linux-gnu/bits/sigset.h" 1 3 4
# 33 "/usr/include/i386-linux-gnu/sys/socket.h" 2 3 4






# 1 "/usr/include/i386-linux-gnu/bits/socket.h" 1 3 4
# 27 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 28 "/usr/include/i386-linux-gnu/bits/socket.h" 2 3 4
# 38 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/socket_type.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/socket_type.h" 3 4
enum __socket_type
{
  SOCK_STREAM = 1,


  SOCK_DGRAM = 2,


  SOCK_RAW = 3,

  SOCK_RDM = 4,

  SOCK_SEQPACKET = 5,


  SOCK_DCCP = 6,

  SOCK_PACKET = 10,







  SOCK_CLOEXEC = 02000000,


  SOCK_NONBLOCK = 00004000


};
# 39 "/usr/include/i386-linux-gnu/bits/socket.h" 2 3 4
# 144 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/sockaddr.h" 1 3 4
# 28 "/usr/include/i386-linux-gnu/bits/sockaddr.h" 3 4
typedef unsigned short int sa_family_t;
# 145 "/usr/include/i386-linux-gnu/bits/socket.h" 2 3 4


struct sockaddr
  {
    sa_family_t sa_family;
    char sa_data[14];
  };
# 160 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
struct sockaddr_storage
  {
    sa_family_t ss_family;
    unsigned long int __ss_align;
    char __ss_padding[(128 - (2 * sizeof (unsigned long int)))];
  };



enum
  {
    MSG_OOB = 0x01,

    MSG_PEEK = 0x02,

    MSG_DONTROUTE = 0x04,



    MSG_TRYHARD = MSG_DONTROUTE,


    MSG_CTRUNC = 0x08,

    MSG_PROXY = 0x10,

    MSG_TRUNC = 0x20,

    MSG_DONTWAIT = 0x40,

    MSG_EOR = 0x80,

    MSG_WAITALL = 0x100,

    MSG_FIN = 0x200,

    MSG_SYN = 0x400,

    MSG_CONFIRM = 0x800,

    MSG_RST = 0x1000,

    MSG_ERRQUEUE = 0x2000,

    MSG_NOSIGNAL = 0x4000,

    MSG_MORE = 0x8000,

    MSG_WAITFORONE = 0x10000,

    MSG_FASTOPEN = 0x20000000,


    MSG_CMSG_CLOEXEC = 0x40000000



  };




struct msghdr
  {
    void *msg_name;
    socklen_t msg_namelen;

    struct iovec *msg_iov;
    size_t msg_iovlen;

    void *msg_control;
    size_t msg_controllen;




    int msg_flags;
  };


struct cmsghdr
  {
    size_t cmsg_len;




    int cmsg_level;
    int cmsg_type;

    __extension__ unsigned char __cmsg_data [];

  };
# 270 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
          struct cmsghdr *__cmsg) throw ();




extern __inline __attribute__ ((__gnu_inline__)) struct cmsghdr *
__attribute__ ((__leaf__)) __cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) throw ()
{
  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))

    return (struct cmsghdr *) 0;

  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
          + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
  if ((unsigned char *) (__cmsg + 1) > ((unsigned char *) __mhdr->msg_control
     + __mhdr->msg_controllen)
      || ((unsigned char *) __cmsg + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1))
   > ((unsigned char *) __mhdr->msg_control + __mhdr->msg_controllen)))

    return (struct cmsghdr *) 0;
  return __cmsg;
}




enum
  {
    SCM_RIGHTS = 0x01


    , SCM_CREDENTIALS = 0x02


  };



struct ucred
{
  pid_t pid;
  uid_t uid;
  gid_t gid;
};
# 343 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
# 1 "/usr/include/i386-linux-gnu/asm/socket.h" 1 3 4
# 1 "/usr/include/asm-generic/socket.h" 1 3 4



# 1 "/usr/include/i386-linux-gnu/asm/sockios.h" 1 3 4
# 1 "/usr/include/asm-generic/sockios.h" 1 3 4
# 1 "/usr/include/i386-linux-gnu/asm/sockios.h" 2 3 4
# 5 "/usr/include/asm-generic/socket.h" 2 3 4
# 1 "/usr/include/i386-linux-gnu/asm/socket.h" 2 3 4
# 344 "/usr/include/i386-linux-gnu/bits/socket.h" 2 3 4
# 377 "/usr/include/i386-linux-gnu/bits/socket.h" 3 4
struct linger
  {
    int l_onoff;
    int l_linger;
  };
# 40 "/usr/include/i386-linux-gnu/sys/socket.h" 2 3 4




struct osockaddr
  {
    unsigned short int sa_family;
    unsigned char sa_data[14];
  };




enum
{
  SHUT_RD = 0,

  SHUT_WR,

  SHUT_RDWR

};
# 102 "/usr/include/i386-linux-gnu/sys/socket.h" 3 4
struct mmsghdr
  {
    struct msghdr msg_hdr;
    unsigned int msg_len;

  };






extern int socket (int __domain, int __type, int __protocol) throw ();





extern int socketpair (int __domain, int __type, int __protocol,
         int __fds[2]) throw ();


extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
     throw ();


extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
   socklen_t *__restrict __len) throw ();
# 138 "/usr/include/i386-linux-gnu/sys/socket.h" 3 4
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);



extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
   socklen_t *__restrict __len) throw ();






extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);






extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);






extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
         int __flags, const struct sockaddr * __addr,
         socklen_t __addr_len);
# 175 "/usr/include/i386-linux-gnu/sys/socket.h" 3 4
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
    int __flags, struct sockaddr *__restrict __addr,
    socklen_t *__restrict __addr_len);







extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
   int __flags);







extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
       unsigned int __vlen, int __flags);







extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);







extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
       unsigned int __vlen, int __flags,
       const struct timespec *__tmo);






extern int getsockopt (int __fd, int __level, int __optname,
         void *__restrict __optval,
         socklen_t *__restrict __optlen) throw ();




extern int setsockopt (int __fd, int __level, int __optname,
         const void *__optval, socklen_t __optlen) throw ();





extern int listen (int __fd, int __n) throw ();
# 244 "/usr/include/i386-linux-gnu/sys/socket.h" 3 4
extern int accept (int __fd, struct sockaddr *__restrict __addr,
     socklen_t *__restrict __addr_len);






extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
      socklen_t *__restrict __addr_len, int __flags);
# 262 "/usr/include/i386-linux-gnu/sys/socket.h" 3 4
extern int shutdown (int __fd, int __how) throw ();




extern int sockatmark (int __fd) throw ();







extern int isfdtype (int __fd, int __fdtype) throw ();





# 1 "/usr/include/i386-linux-gnu/bits/socket2.h" 1 3 4
# 23 "/usr/include/i386-linux-gnu/bits/socket2.h" 3 4
extern ssize_t __recv_chk (int __fd, void *__buf, size_t __n, size_t __buflen,
      int __flags);
extern ssize_t __recv_alias (int __fd, void *__buf, size_t __n, int __flags) __asm__ ("" "recv")
                          ;
extern ssize_t __recv_chk_warn (int __fd, void *__buf, size_t __n, size_t __buflen, int __flags) __asm__ ("" "__recv_chk")


     __attribute__((__warning__ ("recv called with bigger length than size of destination " "buffer")))
            ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) ssize_t
recv (int __fd, void *__buf, size_t __n, int __flags)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __recv_chk (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags);

      if (__n > __builtin_object_size (__buf, 0))
 return __recv_chk_warn (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags);
    }
  return __recv_alias (__fd, __buf, __n, __flags);
}

extern ssize_t __recvfrom_chk (int __fd, void *__restrict __buf, size_t __n,
          size_t __buflen, int __flags,
          struct sockaddr *__restrict __addr,
          socklen_t *__restrict __addr_len);
extern ssize_t __recvfrom_alias (int __fd, void *__restrict __buf, size_t __n, int __flags, struct sockaddr *__restrict __addr, socklen_t *__restrict __addr_len) __asm__ ("" "recvfrom")


                                                   ;
extern ssize_t __recvfrom_chk_warn (int __fd, void *__restrict __buf, size_t __n, size_t __buflen, int __flags, struct sockaddr *__restrict __addr, socklen_t *__restrict __addr_len) __asm__ ("" "__recvfrom_chk")




     __attribute__((__warning__ ("recvfrom called with bigger length than size of " "destination buffer")))
                        ;

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) __attribute__ ((__artificial__)) ssize_t
recvfrom (int __fd, void *__restrict __buf, size_t __n, int __flags,
   struct sockaddr *__restrict __addr, socklen_t *__restrict __addr_len)
{
  if (__builtin_object_size (__buf, 0) != (size_t) -1)
    {
      if (!__builtin_constant_p (__n))
 return __recvfrom_chk (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags,
          __addr, __addr_len);
      if (__n > __builtin_object_size (__buf, 0))
 return __recvfrom_chk_warn (__fd, __buf, __n, __builtin_object_size (__buf, 0), __flags,
        __addr, __addr_len);
    }
  return __recvfrom_alias (__fd, __buf, __n, __flags, __addr, __addr_len);
}
# 282 "/usr/include/i386-linux-gnu/sys/socket.h" 2 3 4


}
# 25 "/usr/include/netinet/in.h" 2 3 4



extern "C" {


enum
  {
    IPPROTO_IP = 0,

    IPPROTO_HOPOPTS = 0,

    IPPROTO_ICMP = 1,

    IPPROTO_IGMP = 2,

    IPPROTO_IPIP = 4,

    IPPROTO_TCP = 6,

    IPPROTO_EGP = 8,

    IPPROTO_PUP = 12,

    IPPROTO_UDP = 17,

    IPPROTO_IDP = 22,

    IPPROTO_TP = 29,

    IPPROTO_DCCP = 33,

    IPPROTO_IPV6 = 41,

    IPPROTO_ROUTING = 43,

    IPPROTO_FRAGMENT = 44,

    IPPROTO_RSVP = 46,

    IPPROTO_GRE = 47,

    IPPROTO_ESP = 50,

    IPPROTO_AH = 51,

    IPPROTO_ICMPV6 = 58,

    IPPROTO_NONE = 59,

    IPPROTO_DSTOPTS = 60,

    IPPROTO_MTP = 92,

    IPPROTO_ENCAP = 98,

    IPPROTO_PIM = 103,

    IPPROTO_COMP = 108,

    IPPROTO_SCTP = 132,

    IPPROTO_UDPLITE = 136,

    IPPROTO_RAW = 255,

    IPPROTO_MAX
  };



typedef uint16_t in_port_t;


enum
  {
    IPPORT_ECHO = 7,
    IPPORT_DISCARD = 9,
    IPPORT_SYSTAT = 11,
    IPPORT_DAYTIME = 13,
    IPPORT_NETSTAT = 15,
    IPPORT_FTP = 21,
    IPPORT_TELNET = 23,
    IPPORT_SMTP = 25,
    IPPORT_TIMESERVER = 37,
    IPPORT_NAMESERVER = 42,
    IPPORT_WHOIS = 43,
    IPPORT_MTP = 57,

    IPPORT_TFTP = 69,
    IPPORT_RJE = 77,
    IPPORT_FINGER = 79,
    IPPORT_TTYLINK = 87,
    IPPORT_SUPDUP = 95,


    IPPORT_EXECSERVER = 512,
    IPPORT_LOGINSERVER = 513,
    IPPORT_CMDSERVER = 514,
    IPPORT_EFSSERVER = 520,


    IPPORT_BIFFUDP = 512,
    IPPORT_WHOSERVER = 513,
    IPPORT_ROUTESERVER = 520,


    IPPORT_RESERVED = 1024,


    IPPORT_USERRESERVED = 5000
  };



typedef uint32_t in_addr_t;
struct in_addr
  {
    in_addr_t s_addr;
  };
# 197 "/usr/include/netinet/in.h" 3 4
struct in6_addr
  {
    union
      {
 uint8_t __u6_addr8[16];

 uint16_t __u6_addr16[8];
 uint32_t __u6_addr32[4];

      } __in6_u;





  };

extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback;
# 224 "/usr/include/netinet/in.h" 3 4
struct sockaddr_in
  {
    sa_family_t sin_family;
    in_port_t sin_port;
    struct in_addr sin_addr;


    unsigned char sin_zero[sizeof (struct sockaddr) -
      (sizeof (unsigned short int)) -
      sizeof (in_port_t) -
      sizeof (struct in_addr)];
  };


struct sockaddr_in6
  {
    sa_family_t sin6_family;
    in_port_t sin6_port;
    uint32_t sin6_flowinfo;
    struct in6_addr sin6_addr;
    uint32_t sin6_scope_id;
  };




struct ip_mreq
  {

    struct in_addr imr_multiaddr;


    struct in_addr imr_interface;
  };

struct ip_mreq_source
  {

    struct in_addr imr_multiaddr;


    struct in_addr imr_interface;


    struct in_addr imr_sourceaddr;
  };




struct ipv6_mreq
  {

    struct in6_addr ipv6mr_multiaddr;


    unsigned int ipv6mr_interface;
  };




struct group_req
  {

    uint32_t gr_interface;


    struct sockaddr_storage gr_group;
  };

struct group_source_req
  {

    uint32_t gsr_interface;


    struct sockaddr_storage gsr_group;


    struct sockaddr_storage gsr_source;
  };



struct ip_msfilter
  {

    struct in_addr imsf_multiaddr;


    struct in_addr imsf_interface;


    uint32_t imsf_fmode;


    uint32_t imsf_numsrc;

    struct in_addr imsf_slist[1];
  };





struct group_filter
  {

    uint32_t gf_interface;


    struct sockaddr_storage gf_group;


    uint32_t gf_fmode;


    uint32_t gf_numsrc;

    struct sockaddr_storage gf_slist[1];
};
# 355 "/usr/include/netinet/in.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/in.h" 1 3 4
# 100 "/usr/include/i386-linux-gnu/bits/in.h" 3 4
struct ip_opts
  {
    struct in_addr ip_dst;
    char ip_opts[40];
  };


struct ip_mreqn
  {
    struct in_addr imr_multiaddr;
    struct in_addr imr_address;
    int imr_ifindex;
  };


struct in_pktinfo
  {
    int ipi_ifindex;
    struct in_addr ipi_spec_dst;
    struct in_addr ipi_addr;
  };
# 356 "/usr/include/netinet/in.h" 2 3 4
# 364 "/usr/include/netinet/in.h" 3 4
extern uint32_t ntohl (uint32_t __netlong) throw () __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
     throw () __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
     throw () __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
     throw () __attribute__ ((__const__));




# 1 "/usr/include/i386-linux-gnu/bits/byteswap.h" 1 3 4
# 376 "/usr/include/netinet/in.h" 2 3 4
# 491 "/usr/include/netinet/in.h" 3 4
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) throw ();


extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
     throw ();
# 521 "/usr/include/netinet/in.h" 3 4
struct cmsghdr;


struct in6_pktinfo
  {
    struct in6_addr ipi6_addr;
    unsigned int ipi6_ifindex;
  };


struct ip6_mtuinfo
  {
    struct sockaddr_in6 ip6m_addr;
    uint32_t ip6m_mtu;
  };



extern int inet6_option_space (int __nbytes)
     throw () __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
         int __type) throw () __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
    const uint8_t *__typep, int __multx,
    int __plusy) throw () __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
        int __multx, int __plusy)
     throw () __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
         uint8_t **__tptrp)
     throw () __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
         uint8_t **__tptrp, int __type)
     throw () __attribute__ ((__deprecated__));



extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) throw ();
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
        uint8_t __type, socklen_t __len, uint8_t __align,
        void **__databufp) throw ();
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
     throw ();
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
         socklen_t __vallen) throw ();
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
      uint8_t *__typep, socklen_t *__lenp,
      void **__databufp) throw ();
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
      uint8_t __type, socklen_t *__lenp,
      void **__databufp) throw ();
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
         socklen_t __vallen) throw ();



extern socklen_t inet6_rth_space (int __type, int __segments) throw ();
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
        int __segments) throw ();
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) throw ();
extern int inet6_rth_reverse (const void *__in, void *__out) throw ();
extern int inet6_rth_segments (const void *__bp) throw ();
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
     throw ();





extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
    struct in_addr __group, uint32_t *__fmode,
    uint32_t *__numsrc, struct in_addr *__slist)
     throw ();


extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
    struct in_addr __group, uint32_t __fmode,
    uint32_t __numsrc,
    const struct in_addr *__slist)
     throw ();



extern int getsourcefilter (int __s, uint32_t __interface_addr,
       const struct sockaddr *__group,
       socklen_t __grouplen, uint32_t *__fmode,
       uint32_t *__numsrc,
       struct sockaddr_storage *__slist) throw ();


extern int setsourcefilter (int __s, uint32_t __interface_addr,
       const struct sockaddr *__group,
       socklen_t __grouplen, uint32_t __fmode,
       uint32_t __numsrc,
       const struct sockaddr_storage *__slist) throw ();


}
# 28 "/usr/include/netdb.h" 2 3 4




# 1 "/usr/include/rpc/netdb.h" 1 3 4
# 42 "/usr/include/rpc/netdb.h" 3 4
# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 43 "/usr/include/rpc/netdb.h" 2 3 4

extern "C" {

struct rpcent
{
  char *r_name;
  char **r_aliases;
  int r_number;
};

extern void setrpcent (int __stayopen) throw ();
extern void endrpcent (void) throw ();
extern struct rpcent *getrpcbyname (const char *__name) throw ();
extern struct rpcent *getrpcbynumber (int __number) throw ();
extern struct rpcent *getrpcent (void) throw ();


extern int getrpcbyname_r (const char *__name, struct rpcent *__result_buf,
      char *__buffer, size_t __buflen,
      struct rpcent **__result) throw ();

extern int getrpcbynumber_r (int __number, struct rpcent *__result_buf,
        char *__buffer, size_t __buflen,
        struct rpcent **__result) throw ();

extern int getrpcent_r (struct rpcent *__result_buf, char *__buffer,
   size_t __buflen, struct rpcent **__result) throw ();


}
# 33 "/usr/include/netdb.h" 2 3 4




# 1 "/usr/include/i386-linux-gnu/bits/siginfo.h" 1 3 4
# 24 "/usr/include/i386-linux-gnu/bits/siginfo.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/wordsize.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/bits/siginfo.h" 2 3 4
# 38 "/usr/include/netdb.h" 2 3 4




# 1 "/usr/include/i386-linux-gnu/bits/netdb.h" 1 3 4
# 26 "/usr/include/i386-linux-gnu/bits/netdb.h" 3 4
struct netent
{
  char *n_name;
  char **n_aliases;
  int n_addrtype;
  uint32_t n_net;
};
# 43 "/usr/include/netdb.h" 2 3 4
# 53 "/usr/include/netdb.h" 3 4
extern "C" {







extern int *__h_errno_location (void) throw () __attribute__ ((__const__));
# 92 "/usr/include/netdb.h" 3 4
extern void herror (const char *__str) throw ();


extern const char *hstrerror (int __err_num) throw ();




struct hostent
{
  char *h_name;
  char **h_aliases;
  int h_addrtype;
  int h_length;
  char **h_addr_list;



};






extern void sethostent (int __stay_open);





extern void endhostent (void);






extern struct hostent *gethostent (void);






extern struct hostent *gethostbyaddr (const void *__addr, __socklen_t __len,
          int __type);





extern struct hostent *gethostbyname (const char *__name);
# 155 "/usr/include/netdb.h" 3 4
extern struct hostent *gethostbyname2 (const char *__name, int __af);
# 167 "/usr/include/netdb.h" 3 4
extern int gethostent_r (struct hostent *__restrict __result_buf,
    char *__restrict __buf, size_t __buflen,
    struct hostent **__restrict __result,
    int *__restrict __h_errnop);

extern int gethostbyaddr_r (const void *__restrict __addr, __socklen_t __len,
       int __type,
       struct hostent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct hostent **__restrict __result,
       int *__restrict __h_errnop);

extern int gethostbyname_r (const char *__restrict __name,
       struct hostent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct hostent **__restrict __result,
       int *__restrict __h_errnop);

extern int gethostbyname2_r (const char *__restrict __name, int __af,
        struct hostent *__restrict __result_buf,
        char *__restrict __buf, size_t __buflen,
        struct hostent **__restrict __result,
        int *__restrict __h_errnop);
# 198 "/usr/include/netdb.h" 3 4
extern void setnetent (int __stay_open);





extern void endnetent (void);






extern struct netent *getnetent (void);






extern struct netent *getnetbyaddr (uint32_t __net, int __type);





extern struct netent *getnetbyname (const char *__name);
# 237 "/usr/include/netdb.h" 3 4
extern int getnetent_r (struct netent *__restrict __result_buf,
   char *__restrict __buf, size_t __buflen,
   struct netent **__restrict __result,
   int *__restrict __h_errnop);

extern int getnetbyaddr_r (uint32_t __net, int __type,
      struct netent *__restrict __result_buf,
      char *__restrict __buf, size_t __buflen,
      struct netent **__restrict __result,
      int *__restrict __h_errnop);

extern int getnetbyname_r (const char *__restrict __name,
      struct netent *__restrict __result_buf,
      char *__restrict __buf, size_t __buflen,
      struct netent **__restrict __result,
      int *__restrict __h_errnop);




struct servent
{
  char *s_name;
  char **s_aliases;
  int s_port;
  char *s_proto;
};






extern void setservent (int __stay_open);





extern void endservent (void);






extern struct servent *getservent (void);






extern struct servent *getservbyname (const char *__name, const char *__proto);






extern struct servent *getservbyport (int __port, const char *__proto);
# 308 "/usr/include/netdb.h" 3 4
extern int getservent_r (struct servent *__restrict __result_buf,
    char *__restrict __buf, size_t __buflen,
    struct servent **__restrict __result);

extern int getservbyname_r (const char *__restrict __name,
       const char *__restrict __proto,
       struct servent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct servent **__restrict __result);

extern int getservbyport_r (int __port, const char *__restrict __proto,
       struct servent *__restrict __result_buf,
       char *__restrict __buf, size_t __buflen,
       struct servent **__restrict __result);




struct protoent
{
  char *p_name;
  char **p_aliases;
  int p_proto;
};






extern void setprotoent (int __stay_open);





extern void endprotoent (void);






extern struct protoent *getprotoent (void);





extern struct protoent *getprotobyname (const char *__name);





extern struct protoent *getprotobynumber (int __proto);
# 374 "/usr/include/netdb.h" 3 4
extern int getprotoent_r (struct protoent *__restrict __result_buf,
     char *__restrict __buf, size_t __buflen,
     struct protoent **__restrict __result);

extern int getprotobyname_r (const char *__restrict __name,
        struct protoent *__restrict __result_buf,
        char *__restrict __buf, size_t __buflen,
        struct protoent **__restrict __result);

extern int getprotobynumber_r (int __proto,
          struct protoent *__restrict __result_buf,
          char *__restrict __buf, size_t __buflen,
          struct protoent **__restrict __result);
# 395 "/usr/include/netdb.h" 3 4
extern int setnetgrent (const char *__netgroup);







extern void endnetgrent (void);
# 412 "/usr/include/netdb.h" 3 4
extern int getnetgrent (char **__restrict __hostp,
   char **__restrict __userp,
   char **__restrict __domainp);
# 423 "/usr/include/netdb.h" 3 4
extern int innetgr (const char *__netgroup, const char *__host,
      const char *__user, const char *__domain);







extern int getnetgrent_r (char **__restrict __hostp,
     char **__restrict __userp,
     char **__restrict __domainp,
     char *__restrict __buffer, size_t __buflen);
# 451 "/usr/include/netdb.h" 3 4
extern int rcmd (char **__restrict __ahost, unsigned short int __rport,
   const char *__restrict __locuser,
   const char *__restrict __remuser,
   const char *__restrict __cmd, int *__restrict __fd2p);
# 463 "/usr/include/netdb.h" 3 4
extern int rcmd_af (char **__restrict __ahost, unsigned short int __rport,
      const char *__restrict __locuser,
      const char *__restrict __remuser,
      const char *__restrict __cmd, int *__restrict __fd2p,
      sa_family_t __af);
# 479 "/usr/include/netdb.h" 3 4
extern int rexec (char **__restrict __ahost, int __rport,
    const char *__restrict __name,
    const char *__restrict __pass,
    const char *__restrict __cmd, int *__restrict __fd2p);
# 491 "/usr/include/netdb.h" 3 4
extern int rexec_af (char **__restrict __ahost, int __rport,
       const char *__restrict __name,
       const char *__restrict __pass,
       const char *__restrict __cmd, int *__restrict __fd2p,
       sa_family_t __af);
# 505 "/usr/include/netdb.h" 3 4
extern int ruserok (const char *__rhost, int __suser,
      const char *__remuser, const char *__locuser);
# 515 "/usr/include/netdb.h" 3 4
extern int ruserok_af (const char *__rhost, int __suser,
         const char *__remuser, const char *__locuser,
         sa_family_t __af);
# 528 "/usr/include/netdb.h" 3 4
extern int iruserok (uint32_t __raddr, int __suser,
       const char *__remuser, const char *__locuser);
# 539 "/usr/include/netdb.h" 3 4
extern int iruserok_af (const void *__raddr, int __suser,
   const char *__remuser, const char *__locuser,
   sa_family_t __af);
# 551 "/usr/include/netdb.h" 3 4
extern int rresvport (int *__alport);
# 560 "/usr/include/netdb.h" 3 4
extern int rresvport_af (int *__alport, sa_family_t __af);






struct addrinfo
{
  int ai_flags;
  int ai_family;
  int ai_socktype;
  int ai_protocol;
  socklen_t ai_addrlen;
  struct sockaddr *ai_addr;
  char *ai_canonname;
  struct addrinfo *ai_next;
};



struct gaicb
{
  const char *ar_name;
  const char *ar_service;
  const struct addrinfo *ar_request;
  struct addrinfo *ar_result;

  int __return;
  int __unused[5];
};
# 662 "/usr/include/netdb.h" 3 4
extern int getaddrinfo (const char *__restrict __name,
   const char *__restrict __service,
   const struct addrinfo *__restrict __req,
   struct addrinfo **__restrict __pai);


extern void freeaddrinfo (struct addrinfo *__ai) throw ();


extern const char *gai_strerror (int __ecode) throw ();





extern int getnameinfo (const struct sockaddr *__restrict __sa,
   socklen_t __salen, char *__restrict __host,
   socklen_t __hostlen, char *__restrict __serv,
   socklen_t __servlen, int __flags);
# 692 "/usr/include/netdb.h" 3 4
extern int getaddrinfo_a (int __mode, struct gaicb *__list[],
     int __ent, struct sigevent *__restrict __sig);
# 703 "/usr/include/netdb.h" 3 4
extern int gai_suspend (const struct gaicb *const __list[], int __ent,
   const struct timespec *__timeout);


extern int gai_error (struct gaicb *__req) throw ();


extern int gai_cancel (struct gaicb *__gaicbp) throw ();


}
# 32 "./drizzled/session.h" 2

# 1 "/usr/include/i386-linux-gnu/sys/resource.h" 1 3 4
# 25 "/usr/include/i386-linux-gnu/sys/resource.h" 3 4
# 1 "/usr/include/i386-linux-gnu/bits/resource.h" 1 3 4
# 31 "/usr/include/i386-linux-gnu/bits/resource.h" 3 4
enum __rlimit_resource
{

  RLIMIT_CPU = 0,



  RLIMIT_FSIZE = 1,



  RLIMIT_DATA = 2,



  RLIMIT_STACK = 3,



  RLIMIT_CORE = 4,






  __RLIMIT_RSS = 5,



  RLIMIT_NOFILE = 7,
  __RLIMIT_OFILE = RLIMIT_NOFILE,




  RLIMIT_AS = 9,



  __RLIMIT_NPROC = 6,



  __RLIMIT_MEMLOCK = 8,



  __RLIMIT_LOCKS = 10,



  __RLIMIT_SIGPENDING = 11,



  __RLIMIT_MSGQUEUE = 12,





  __RLIMIT_NICE = 13,




  __RLIMIT_RTPRIO = 14,





  __RLIMIT_RTTIME = 15,


  __RLIMIT_NLIMITS = 16,
  __RLIM_NLIMITS = __RLIMIT_NLIMITS


};
# 133 "/usr/include/i386-linux-gnu/bits/resource.h" 3 4
typedef __rlim64_t rlim_t;


typedef __rlim64_t rlim64_t;


struct rlimit
  {

    rlim_t rlim_cur;

    rlim_t rlim_max;
  };


struct rlimit64
  {

    rlim64_t rlim_cur;

    rlim64_t rlim_max;
 };



enum __rusage_who
{

  RUSAGE_SELF = 0,



  RUSAGE_CHILDREN = -1



  ,

  RUSAGE_THREAD = 1




};


# 1 "/usr/include/i386-linux-gnu/bits/time.h" 1 3 4
# 180 "/usr/include/i386-linux-gnu/bits/resource.h" 2 3 4







struct rusage
  {

    struct timeval ru_utime;

    struct timeval ru_stime;

    __extension__ union
      {
 long int ru_maxrss;
 __syscall_slong_t __ru_maxrss_word;
      };



    __extension__ union
      {
 long int ru_ixrss;
 __syscall_slong_t __ru_ixrss_word;
      };

    __extension__ union
      {
 long int ru_idrss;
 __syscall_slong_t __ru_idrss_word;
      };

    __extension__ union
      {
 long int ru_isrss;
  __syscall_slong_t __ru_isrss_word;
      };


    __extension__ union
      {
 long int ru_minflt;
 __syscall_slong_t __ru_minflt_word;
      };

    __extension__ union
      {
 long int ru_majflt;
 __syscall_slong_t __ru_majflt_word;
      };

    __extension__ union
      {
 long int ru_nswap;
 __syscall_slong_t __ru_nswap_word;
      };


    __extension__ union
      {
 long int ru_inblock;
 __syscall_slong_t __ru_inblock_word;
      };

    __extension__ union
      {
 long int ru_oublock;
 __syscall_slong_t __ru_oublock_word;
      };

    __extension__ union
      {
 long int ru_msgsnd;
 __syscall_slong_t __ru_msgsnd_word;
      };

    __extension__ union
      {
 long int ru_msgrcv;
 __syscall_slong_t __ru_msgrcv_word;
      };

    __extension__ union
      {
 long int ru_nsignals;
 __syscall_slong_t __ru_nsignals_word;
      };



    __extension__ union
      {
 long int ru_nvcsw;
 __syscall_slong_t __ru_nvcsw_word;
      };


    __extension__ union
      {
 long int ru_nivcsw;
 __syscall_slong_t __ru_nivcsw_word;
      };
  };







enum __priority_which
{
  PRIO_PROCESS = 0,

  PRIO_PGRP = 1,

  PRIO_USER = 2

};


extern "C" {
# 313 "/usr/include/i386-linux-gnu/bits/resource.h" 3 4
extern int prlimit (__pid_t __pid, enum __rlimit_resource __resource, const struct rlimit *__new_limit, struct rlimit *__old_limit) throw () __asm__ ("" "prlimit64")


                                                ;





extern int prlimit64 (__pid_t __pid, enum __rlimit_resource __resource,
        const struct rlimit64 *__new_limit,
        struct rlimit64 *__old_limit) throw ();



}
# 26 "/usr/include/i386-linux-gnu/sys/resource.h" 2 3 4






extern "C" {
# 43 "/usr/include/i386-linux-gnu/sys/resource.h" 3 4
typedef int __rlimit_resource_t;
typedef int __rusage_who_t;
typedef int __priority_which_t;
# 55 "/usr/include/i386-linux-gnu/sys/resource.h" 3 4
extern int getrlimit (__rlimit_resource_t __resource, struct rlimit *__rlimits) throw () __asm__ ("" "getrlimit64")
                                                  ;





extern int getrlimit64 (__rlimit_resource_t __resource,
   struct rlimit64 *__rlimits) throw ();
# 74 "/usr/include/i386-linux-gnu/sys/resource.h" 3 4
extern int setrlimit (__rlimit_resource_t __resource, const struct rlimit *__rlimits) throw () __asm__ ("" "setrlimit64")

                  ;





extern int setrlimit64 (__rlimit_resource_t __resource,
   const struct rlimit64 *__rlimits) throw ();




extern int getrusage (__rusage_who_t __who, struct rusage *__usage) throw ();





extern int getpriority (__priority_which_t __which, id_t __who) throw ();



extern int setpriority (__priority_which_t __which, id_t __who, int __prio)
     throw ();

}
# 34 "./drizzled/session.h" 2





# 1 "./drizzled/lock.h" 1
# 20 "./drizzled/lock.h"
       


# 1 "./drizzled/thr_lock.h" 1
# 18 "./drizzled/thr_lock.h"
       
# 27 "./drizzled/thr_lock.h"
namespace drizzled {

extern uint64_t max_write_lock_count;
extern uint64_t table_lock_wait_timeout;

enum thr_lock_type
{
                     TL_IGNORE=-1,

                     TL_UNLOCK,

                     TL_READ,
                     TL_READ_WITH_SHARED_LOCKS,

                     TL_READ_NO_INSERT,





                     TL_WRITE_ALLOW_WRITE,





                     TL_WRITE_ALLOW_READ,




                     TL_WRITE_CONCURRENT_INSERT,




                     TL_WRITE_DEFAULT,

                     TL_WRITE,

                     TL_WRITE_ONLY
};

enum enum_thr_lock_result
{
  THR_LOCK_SUCCESS= 0,
  THR_LOCK_ABORTED= 1,
  THR_LOCK_WAIT_TIMEOUT= 2,
  THR_LOCK_DEADLOCK= 3
};






struct THR_LOCK_INFO
{
  uint64_t thread_id;
  uint32_t n_cursors;

  THR_LOCK_INFO() :
    thread_id(0),
    n_cursors(0)
  { }

  void init();

};







struct THR_LOCK_OWNER
{
  THR_LOCK_INFO *info;

  THR_LOCK_OWNER() :
    info(__null)
  { }

};

struct THR_LOCK;
struct THR_LOCK_DATA;

struct __attribute__ ((visibility("default"))) THR_LOCK_DATA
{
  THR_LOCK_OWNER *owner;
  struct THR_LOCK_DATA *next,**prev;
  struct THR_LOCK *lock;
  boost::condition_variable_any *cond;
  enum thr_lock_type type;
  void *status_param;

  THR_LOCK_DATA() :
    owner(0),
    next(0),
    prev(0),
    lock(0),
    cond(0),
    type(TL_UNLOCK),
    status_param(0)
  { }

  void init(THR_LOCK*, void *status_param= __null);
};

struct st_lock_list
{
  THR_LOCK_DATA *data,**last;

  st_lock_list() :
    data(0),
    last(0)
  { }
};

struct THR_LOCK
{
private:
  boost::mutex mutex;
public:
  struct st_lock_list read_wait;
  struct st_lock_list read;
  struct st_lock_list write_wait;
  struct st_lock_list write;

  uint32_t write_lock_count;
  uint32_t read_no_write_count;

  THR_LOCK() :
    write_lock_count(0),
    read_no_write_count(0)
  { }

  void abort_locks();
  bool abort_locks_for_thread(uint64_t thread);

  void lock()
  {
    mutex.lock();
  }

  void unlock()
  {
    mutex.unlock();
  }

  boost::mutex *native_handle()
  {
    return &mutex;
  }
};

__attribute__ ((visibility("default"))) void thr_lock_init(THR_LOCK *lock);
enum_thr_lock_result thr_multi_lock(Session&, THR_LOCK_DATA**, uint32_t count, THR_LOCK_OWNER*);
void thr_multi_unlock(THR_LOCK_DATA**, uint32_t count);

}
# 24 "./drizzled/lock.h" 2
# 1 "./drizzled/locking/global.h" 1
# 20 "./drizzled/locking/global.h"
       

namespace drizzled
{

namespace locking
{

void broadcast_refresh(void);


}
}
# 25 "./drizzled/lock.h" 2

namespace drizzled {

class DrizzleLock
{
public:
  Table **getTable()
  {
    return &table[0];
  }

  THR_LOCK_DATA **getLocks()
  {
    return &locks[0];
  }

  size_t sizeTable() const
  {
    return table.size();
  }

  void resizeTable(size_t arg)
  {
    table.resize(arg);
  }

  size_t sizeLock() const
  {
    return lock_count;
  }

  void resetLock()
  {
    lock_count= 0;
  }

  void setLock(size_t arg)
  {
    lock_count= arg;
  }

  void reset(void);
  void unlock(uint32_t count);

  DrizzleLock(size_t table_count_arg)
  {
    table.resize(table_count_arg);
    lock_count= table_count_arg * 2;
    locks.resize(lock_count);
  }

private:
  uint32_t lock_count;

  std::vector<Table *> table;
  std::vector<THR_LOCK_DATA *> locks;
  std::vector<THR_LOCK_DATA *> copy_of;
};







}
# 40 "./drizzled/session.h" 2
# 1 "./drizzled/pthread_globals.h" 1
# 20 "./drizzled/pthread_globals.h"
       
# 29 "./drizzled/pthread_globals.h"
namespace drizzled {

typedef boost::shared_ptr<boost::thread> thread_ptr;

extern boost::condition_variable_any COND_refresh;
extern __attribute__ ((visibility("default"))) boost::condition_variable COND_thread_count;
extern pthread_t signal_thread;

}
# 41 "./drizzled/session.h" 2
# 1 "./drizzled/sql_error.h" 1
# 20 "./drizzled/sql_error.h"
       







namespace drizzled {

class DRIZZLE_ERROR : public memory::SqlAlloc
{
public:
  static const uint32_t NUM_ERRORS= 4;
  enum enum_warning_level
  {
    WARN_LEVEL_NOTE,
    WARN_LEVEL_WARN,
    WARN_LEVEL_ERROR,
    WARN_LEVEL_END
  };

  drizzled::error_t code;
  enum_warning_level level;
  const char *msg;

  DRIZZLE_ERROR(Session *session, drizzled::error_t code_arg, enum_warning_level level_arg, const char *msg_arg) :
    code(code_arg),
    level(level_arg)
  {
    if (msg_arg)
      set_msg(session, msg_arg);
  }

  void set_msg(Session *session, const char *msg_arg);
};

__attribute__ ((visibility("default"))) DRIZZLE_ERROR *push_warning(Session*, DRIZZLE_ERROR::enum_warning_level level, error_t code, const char *msg);

__attribute__ ((visibility("default"))) void push_warning_printf(Session*, DRIZZLE_ERROR::enum_warning_level level, error_t code, const char *format, ...);

void drizzle_reset_errors(Session&, bool force);
bool show_warnings(Session *session, std::bitset<DRIZZLE_ERROR::NUM_ERRORS> &levels_to_show);

extern const lex_string_t warning_level_names[];

}
# 42 "./drizzled/session.h" 2
# 1 "./drizzled/sql_locale.h" 1
# 20 "./drizzled/sql_locale.h"
       



namespace drizzled {

typedef struct my_locale_st
{
  uint32_t number;
  const bool is_ascii;
  const char *name;
  const char *description;
  TYPELIB *month_names;
  TYPELIB *ab_month_names;
  TYPELIB *day_names;
  TYPELIB *ab_day_names;
  my_locale_st(uint32_t number_par,
               const char *name_par, const char *descr_par, bool is_ascii_par,
               TYPELIB *month_names_par, TYPELIB *ab_month_names_par,
               TYPELIB *day_names_par, TYPELIB *ab_day_names_par) :
    number(number_par), is_ascii(is_ascii_par),
    name(name_par), description(descr_par),
    month_names(month_names_par), ab_month_names(ab_month_names_par),
    day_names(day_names_par), ab_day_names(ab_day_names_par)
  {}
} MY_LOCALE;

extern MY_LOCALE my_locale_en_US;
extern MY_LOCALE *my_locales[];
extern MY_LOCALE *my_default_lc_time_names;

MY_LOCALE *my_locale_by_name(const char *name);
MY_LOCALE *my_locale_by_number(uint32_t number);

}
# 43 "./drizzled/session.h" 2

# 1 "./drizzled/util/find_ptr.h" 1
# 18 "./drizzled/util/find_ptr.h"
       

template <class T, class U>
typename T::value_type::second_type* find_ptr(T& c, U v)
{
 typename T::iterator i = c.find(v);
 return i == c.end() ? __null : &i->second;
}

template <class T, class U>
const typename T::value_type::second_type* find_ptr(const T& c, U v)
{
 typename T::const_iterator i = c.find(v);
 return i == c.end() ? __null : &i->second;
}

template <class T, class U>
typename T::value_type::second_type find_ptr2(T& c, U v)
{
 typename T::value_type::second_type* i = find_ptr(c, v);
 return i ? *i : __null;
}

template <class T, class U>
const typename T::value_type::second_type find_ptr2(const T& c, U v)
{
 const typename T::value_type::second_type* i = find_ptr(c, v);
 return i ? *i : __null;
}
# 45 "./drizzled/session.h" 2
# 1 "./drizzled/util/string.h" 1
# 36 "./drizzled/util/string.h"
       






# 1 "/usr/include/boost/foreach.hpp" 1 3 4
# 27 "/usr/include/boost/foreach.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 28 "/usr/include/boost/foreach.hpp" 2 3 4
# 89 "/usr/include/boost/foreach.hpp" 3 4
# 1 "/usr/include/boost/foreach_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/foreach_fwd.hpp" 3 4
enum boost_foreach_argument_dependent_lookup_hack
{
    boost_foreach_argument_dependent_lookup_hack_value
};

namespace boost
{

namespace foreach
{



    typedef boost_foreach_argument_dependent_lookup_hack tag;





    template<typename T>
    struct is_lightweight_proxy;





    template<typename T>
    struct is_noncopyable;

}

}
# 90 "/usr/include/boost/foreach.hpp" 2 3 4
# 98 "/usr/include/boost/foreach.hpp" 3 4
namespace boost
{


template<typename T>
class iterator_range;


template<typename T>
class sub_range;

namespace 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>
        >







    {
    };

}

}
# 167 "/usr/include/boost/foreach.hpp" 3 4
template<typename T>
inline boost::foreach::is_lightweight_proxy<T> *
boost_foreach_is_lightweight_proxy(T *&, boost::foreach::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::foreach::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::foreach::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::foreach::tag) { return 0; }

template<typename T>
inline boost::mpl::true_ *
boost_foreach_is_lightweight_proxy(T **&, boost::foreach::tag) { return 0; }






template<typename T>
inline boost::foreach::is_noncopyable<T> *
boost_foreach_is_noncopyable(T *&, boost::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; }
# 245 "/usr/include/boost/foreach.hpp" 3 4
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
{
# 353 "/usr/include/boost/foreach.hpp" 3 4
    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
{
# 384 "/usr/include/boost/foreach.hpp" 3 4
    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;
}
# 517 "/usr/include/boost/foreach.hpp" 3 4
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((*(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((*(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((*(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((*(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);
}

}
}
# 44 "./drizzled/util/string.h" 2
# 1 "/usr/include/boost/functional/hash.hpp" 1 3 4





# 1 "/usr/include/boost/functional/hash/hash.hpp" 1 3 4
# 7 "/usr/include/boost/functional/hash.hpp" 2 3 4
# 45 "./drizzled/util/string.h" 2




namespace drizzled {
namespace util {

struct insensitive_equal_to : std::binary_function<std::string, std::string, bool>
{
  bool operator()(std::string const& x, std::string const& y) const
  {
    return boost::algorithm::iequals(x, y);
  }
};

struct insensitive_hash : std::unary_function<std::string, std::size_t>
{
  std::size_t operator()(std::string const& x) const
  {
    std::size_t seed = 0;
    if (bool _foreach_is_rvalue65 = false) {} else if (boost::foreach_detail_::auto_any_t _foreach_col65 = boost::foreach_detail_::contain( (true ? boost::foreach_detail_::make_probe((x), _foreach_is_rvalue65) : (x)) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(x) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(x))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue65)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_cur65 = boost::foreach_detail_::begin( _foreach_col65 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(x) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(x))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue65)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_end65 = boost::foreach_detail_::end( _foreach_col65 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(x) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(x))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue65)))) {} else for (bool _foreach_continue65 = true; _foreach_continue65 && !boost::foreach_detail_::done( _foreach_cur65 , _foreach_end65 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x)))); _foreach_continue65 ? boost::foreach_detail_::next( _foreach_cur65 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x)))) : (void)0) if (boost::foreach_detail_::set_false(_foreach_continue65)) {} else for (std::string::const_reference it = boost::foreach_detail_::deref( _foreach_cur65 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x)))); !_foreach_continue65; _foreach_continue65 = true)
      boost::hash_combine(seed, std::toupper(it));
    return seed;
  }
};

struct sensitive_hash : std::unary_function< std::vector<char>, std::size_t>
{
  std::size_t operator()(std::vector<char> const& x) const
  {
    std::size_t seed = 0;
    if (bool _foreach_is_rvalue76 = false) {} else if (boost::foreach_detail_::auto_any_t _foreach_col76 = boost::foreach_detail_::contain( (true ? boost::foreach_detail_::make_probe((x), _foreach_is_rvalue76) : (x)) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(x) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(x))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue76)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_cur76 = boost::foreach_detail_::begin( _foreach_col76 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(x) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(x))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue76)))) {} else if (boost::foreach_detail_::auto_any_t _foreach_end76 = boost::foreach_detail_::end( _foreach_col76 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x))) , (boost::foreach_detail_::should_copy_impl( true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::is_array_(x) , boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value) , boost::foreach_detail_::not_(boost::foreach_detail_::is_const_(x))) , true ? 0 : boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(x) , boost_foreach_argument_dependent_lookup_hack_value)) , &_foreach_is_rvalue76)))) {} else for (bool _foreach_continue76 = true; _foreach_continue76 && !boost::foreach_detail_::done( _foreach_cur76 , _foreach_end76 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x)))); _foreach_continue76 ? boost::foreach_detail_::next( _foreach_cur76 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x)))) : (void)0) if (boost::foreach_detail_::set_false(_foreach_continue76)) {} else for (std::vector<char>::const_reference it = boost::foreach_detail_::deref( _foreach_cur76 , (true ? 0 : boost::foreach_detail_::encode_type(x, boost::foreach_detail_::is_const_(x)))); !_foreach_continue76; _foreach_continue76 = true)
      boost::hash_combine(seed, it);
    return seed;
  }
};

class String
{
public:

  String()
  {
    _bytes.resize(1);
  }

  const char* data() const
  {
    return &_bytes[0];
  }

  char* data()
  {
    return &_bytes[0];
  }

  void assign(const size_t repeat, const char arg)
  {
    _bytes.resize(repeat + 1);
    memset(&_bytes[0], arg, repeat);
    _bytes[repeat]= 0;
  }

  void assign(const char *arg, const size_t arg_size)
  {
    _bytes.resize(arg_size + 1);
    memcpy(&_bytes[0], arg, arg_size);
    _bytes[arg_size]= 0;
  }

  void append(const char *arg, const size_t arg_size)
  {
    if (not arg or not arg_size)
      return;

    size_t original_size= size();
    if (original_size)
    {
      _bytes.resize(original_size + arg_size + 1);
      memcpy(&_bytes[original_size], arg, arg_size);
      _bytes[original_size + arg_size]= 0;
    }
    else
    {
      assign(arg, arg_size);
    }
  }

  const char& operator[] (size_t arg) const
  {
    return _bytes[arg];
  }

  char& operator[] (size_t arg)
  {
    return _bytes[arg];
  }

  void clear()
  {
    _bytes.resize(1);
    _bytes[0]= 0;
  }

  size_t size() const
  {
    return _bytes.size() -1;
  }

private:
  std::vector<char> _bytes;
};

}
}
# 46 "./drizzled/session.h" 2


namespace drizzled {

extern uint32_t server_id;
extern std::string server_uuid;



extern uint32_t tc_heuristic_recover;

extern __attribute__ ((visibility("default"))) struct drizzle_system_variables global_system_variables;
# 79 "./drizzled/session.h"
class Open_tables_state;

class __attribute__ ((visibility("default"))) Session
{
private:
  class impl_c;

  boost::scoped_ptr<impl_c> impl_;
public:
  typedef boost::shared_ptr<Session> shared_ptr;

  static shared_ptr make_shared(plugin::Client *client, boost::shared_ptr<catalog::Instance> instance_arg)
  {
    ((instance_arg) ? static_cast<void> (0) : __assert_fail ("instance_arg", "./drizzled/session.h", 92, __PRETTY_FUNCTION__));
    return boost::make_shared<Session>(client, instance_arg);
  }
# 107 "./drizzled/session.h"
  enum_mark_columns mark_used_columns;


  void free_items();





  Item *free_list;
  memory::Root& mem;
  memory::Root* mem_root;

  uint64_t getXaId() const
  {
    return xa_id;
  }

  void setXaId(uint64_t in_xa_id)
  {
    xa_id= in_xa_id;
  }

public:
  Diagnostics_area& main_da();
  const LEX& lex() const;
  LEX& lex();
  enum_sql_command getSqlCommand() const;


  typedef boost::shared_ptr<const std::string> QueryString;

private:
  boost::shared_ptr<std::string> query;




public:
  void resetQueryString();
  const boost::shared_ptr<session::State>& state();

  QueryString getQueryString() const
  {
    return query;
  }

  const char* getQueryStringCopy(size_t &length)
  {
    QueryString tmp_string(getQueryString());
    if (not tmp_string)
    {
      length= 0;
      return __null;
    }
    length= tmp_string->length();
    return mem.strdup(*tmp_string);
  }

  util::string::ptr schema() const;







  static const char* const DEFAULT_WHERE;

  memory::Root warn_root;
public:
  void setClient(plugin::Client *client_arg);

  plugin::Client *getClient() const
  {
    return client;
  }

  plugin::Scheduler* scheduler;

  typedef boost::unordered_map<std::string, user_var_entry*, util::insensitive_hash, util::insensitive_equal_to> UserVars;

private:
  typedef std::pair< UserVars::iterator, UserVars::iterator > UserVarsRange;
  UserVars user_vars;

public:
  const UserVars &getUserVariables() const
  {
    return user_vars;
  }

  drizzle_system_variables& variables;
  enum_tx_isolation getTxIsolation() const;
  system_status_var& status_var;

  THR_LOCK_INFO lock_info;
  THR_LOCK_OWNER main_lock_id;
  THR_LOCK_OWNER *lock_id;





  char *thread_stack;

  identifier::user::ptr user() const
  {
    return security_ctx;
  }

  void setUser(identifier::user::mptr arg)
  {
    security_ctx= arg;
  }

  int32_t getScoreboardIndex() const
  {
    return scoreboard_index;
  }

  void setScoreboardIndex(int32_t in_scoreboard_index)
  {
    scoreboard_index= in_scoreboard_index;
  }

  bool isOriginatingServerUUIDSet() const
  {
    return originating_server_uuid_set;
  }

  void setOriginatingServerUUID(std::string in_originating_server_uuid)
  {
    originating_server_uuid= in_originating_server_uuid;
    originating_server_uuid_set= true;
  }

  const std::string &getOriginatingServerUUID() const
  {
    return originating_server_uuid;
  }

  void setOriginatingCommitID(uint64_t in_originating_commit_id)
  {
    originating_commit_id= in_originating_commit_id;
  }

  uint64_t getOriginatingCommitID() const
  {
    return originating_commit_id;
  }




  bool isViewable(const identifier::User&) const;

private:





  const char *_where;

public:
  const char *where() const
  {
    return _where;
  }

  void setWhere(const char *arg)
  {
    _where= arg;
  }







private:
  boost::thread::id boost_thread_id;
  thread_ptr _thread;
  boost::this_thread::disable_interruption *interrupt;

  internal::st_my_thread_var *mysys_var;

public:
  thread_ptr &getThread()
  {
    return _thread;
  }

  void pushInterrupt(boost::this_thread::disable_interruption *interrupt_arg)
  {
    interrupt= interrupt_arg;
  }

  boost::this_thread::disable_interruption &getThreadInterupt()
  {
    ((interrupt) ? static_cast<void> (0) : __assert_fail ("interrupt", "./drizzled/session.h", 309, __PRETTY_FUNCTION__));
    return *interrupt;
  }

  internal::st_my_thread_var *getThreadVar()
  {
    return mysys_var;
  }





  enum_server_command command;

  thr_lock_type update_lock_default;





private:

  std::vector<Ha_data> ha_data;
# 341 "./drizzled/session.h"
  query_id_t query_id;
  query_id_t warn_query_id;

public:
  void **getEngineData(const plugin::MonitoredInTransaction *monitored);
  ResourceContext& getResourceContext(const plugin::MonitoredInTransaction&, size_t index= 0);

  session::Transactions& transaction;
  Open_tables_state& open_tables;
 session::Times& times;

  Field *dup_field;
  sigset_t signals;

public:

  void setConcurrentExecute(bool arg)
  {
    concurrent_execute_allowed= arg;
  }

  bool isConcurrentExecuteAllowed() const
  {
    return concurrent_execute_allowed;
  }
# 379 "./drizzled/session.h"
  uint64_t first_successful_insert_id_in_prev_stmt;





  uint64_t first_successful_insert_id_in_cur_stmt;
# 399 "./drizzled/session.h"
  uint64_t limit_found_rows;
  uint64_t options;
  int64_t row_count_func;

  int64_t rowCount() const
  {
    return row_count_func;
  }

  ha_rows cuted_fields;





  ha_rows sent_row_count;




  ha_rows examined_row_count;
# 430 "./drizzled/session.h"
  table_map used_tables;
# 440 "./drizzled/session.h"
  uint32_t warn_count[(uint32_t) DRIZZLE_ERROR::WARN_LEVEL_END];
  uint32_t total_warn_count;





  uint32_t row_count;

  session_id_t thread_id;
  uint32_t tmp_table;
  enum global_read_lock_t
  {
    NONE= 0,
    GOT_GLOBAL_READ_LOCK= 1,
    MADE_GLOBAL_READ_LOCK_BLOCK_COMMIT= 2
  };
private:
  global_read_lock_t _global_read_lock;

public:

  global_read_lock_t isGlobalReadLock() const
  {
    return _global_read_lock;
  }

  void setGlobalReadLock(global_read_lock_t arg)
  {
    _global_read_lock= arg;
  }

  DrizzleLock *lockTables(Table **tables, uint32_t count, uint32_t flags);
  bool lockGlobalReadLock();
  bool lock_table_names(TableList *table_list);
  bool lock_table_names_exclusively(TableList *table_list);
  bool makeGlobalReadLockBlockCommit();
  bool abortLockForThread(Table *table);
  bool wait_if_global_read_lock(bool abort_on_refresh, bool is_not_commit);
  int lock_table_name(TableList *table_list);
  void abortLock(Table *table);
  void removeLock(Table *table);
  void unlockReadTables(DrizzleLock *sql_lock);
  void unlockSomeTables(Table **table, uint32_t count);
  void unlockTables(DrizzleLock *sql_lock);
  void startWaitingGlobalReadLock();
  void unlockGlobalReadLock();

private:
  int unlock_external(Table **table, uint32_t count);
  int lock_external(Table **tables, uint32_t count);
  bool wait_for_locked_table_names(TableList *table_list);
  DrizzleLock *get_lock_data(Table **table_ptr, uint32_t count,
                             bool should_lock, Table **write_lock_used);
public:

  uint32_t server_status;
  uint32_t open_options;
  uint32_t select_number;

  enum_tx_isolation session_tx_isolation;
  enum_check_fields count_cuted_fields;

  enum killed_state_t
  {
    NOT_KILLED,
    KILL_BAD_DATA,
    KILL_CONNECTION,
    KILL_QUERY,
    KILLED_NO_VALUE
  };
private:
  killed_state_t volatile _killed;

public:

  void setKilled(killed_state_t arg)
  {
    _killed= arg;
  }

  killed_state_t getKilled() const
  {
    return _killed;
  }

  volatile killed_state_t *getKilledPtr()
  {
    return &_killed;
  }

  bool is_admin_connection;
  bool no_errors;







  bool is_fatal_error;





  bool transaction_rollback_request;
# 558 "./drizzled/session.h"
  bool is_fatal_sub_stmt_error;

  bool substitute_null_with_insert_id;
  bool cleanup_done;

public:
  bool got_warning;
  bool no_warnings_for_error;

  bool derived_tables_processing;

  bool doing_tablespace_operation() const
  {
    return tablespace_op;
  }

  void setDoingTablespaceOperation(bool doing)
  {
    tablespace_op= doing;
  }



  union
  {
    bool bool_value;
    uint32_t uint32_t_value;
    int32_t int32_t_value;
    uint64_t uint64_t_value;
  } sys_var_tmp;
# 596 "./drizzled/session.h"
  Lex_input_stream *m_lip;


  void *session_marker;
# 609 "./drizzled/session.h"
  inline void set_proc_info(const char *info)
  {
    proc_info= info;
  }
  inline const char* get_proc_info() const
  {
    return proc_info;
  }


  inline void setQueryId(query_id_t in_query_id)
  {
    query_id= in_query_id;
  }


  query_id_t getQueryId() const
  {
    return query_id;
  }



  inline void setWarningQueryId(query_id_t in_query_id)
  {
    warn_query_id= in_query_id;
  }


  inline query_id_t getWarningQueryId() const
  {
    return warn_query_id;
  }


  inline session_id_t getSessionId() const
  {
    return thread_id;
  }


  inline uint32_t getServerId() const
  {

    return server_id;
  }

  inline std::string &getServerUUID() const
  {
    return server_uuid;
  }

  inline void record_first_successful_insert_id_in_cur_stmt(uint64_t id_arg)
  {
    if (first_successful_insert_id_in_cur_stmt == 0)
      first_successful_insert_id_in_cur_stmt= id_arg;
  }
  inline uint64_t read_first_successful_insert_id_in_prev_stmt() const
  {
    return first_successful_insert_id_in_prev_stmt;
  }

  Session(plugin::Client*, boost::shared_ptr<catalog::Instance>);
  ~Session();

  void cleanup();
# 687 "./drizzled/session.h"
  void cleanup_after_query();
  void storeGlobals();
  void awake(Session::killed_state_t state_to_set);







  void prepareForQueries();
# 713 "./drizzled/session.h"
  bool executeStatement();
# 731 "./drizzled/session.h"
  void readAndStoreQuery(const char *in_packet, uint32_t in_packet_length);
# 741 "./drizzled/session.h"
  bool endTransaction(enum enum_mysql_completiontype completion);
  bool endActiveTransaction();
  bool startTransaction(start_transaction_option_t opt= START_TRANS_NO_OPTIONS);
  void markTransactionForRollback(bool all);






  bool authenticate();
  void run();
  static bool schedule(const Session::shared_ptr&);
  static void unlink(session_id_t&);
  static void unlink(const Session::shared_ptr&);






  const char* enter_cond(boost::condition_variable_any &cond, boost::mutex &mutex, const char* msg);
  void exit_cond(const char* old_msg);

  uint64_t found_rows() const
  {
    return limit_found_rows;
  }


  bool inTransaction() const
  {
    return server_status & 1;
  }

  lex_string_t* make_lex_string(lex_string_t*, str_ref);

  void send_explain_fields(select_result*);

  void clear_error(bool full= false);
  void clearDiagnostics();
  bool is_error() const;

  static const charset_info_st *charset() { return default_charset_info; }
# 794 "./drizzled/session.h"
  void end_statement();
  inline int killed_errno() const
  {
    killed_state_t killed_val;
    return (killed_val= _killed) != KILL_BAD_DATA ? killed_val : 0;
  }
  void send_kill_message() const;

  inline bool abortOnWarning()
  {
    return abort_on_warning;
  }

  inline void setAbortOnWarning(bool arg)
  {
    abort_on_warning= arg;
  }

  void setAbort(bool arg);
  void lockOnSys();
  void set_status_var_init();
# 832 "./drizzled/session.h"
  void set_schema(const std::string&);






  str_ref copy_db_to() const;

public:
# 856 "./drizzled/session.h"
  void reset_for_next_command();
# 866 "./drizzled/session.h"
  void disconnect(enum error_t errcode= EE_OK);
# 880 "./drizzled/session.h"
  bool checkUser(const std::string &passwd, const std::string &db);






  message::Transaction *getTransactionMessage() const
  {
    return transaction_message;
  }





  message::Statement *getStatementMessage() const
  {
    return statement_message;
  }





  message::Resultset *getResultsetMessage() const
  {
    return resultset;
  }






  void setTransactionMessage(message::Transaction *in_message)
  {
    transaction_message= in_message;
  }







  void setStatementMessage(message::Statement *in_message)
  {
    statement_message= in_message;
  }







  void setResultsetMessage(message::Resultset *in_message)
  {
    resultset= in_message;
  }





  void resetResultsetMessage()
  {
    resultset= __null;
  }

  plugin::EventObserverList *getSessionObservers()
  {
    return session_event_observers;
  }

  void setSessionObservers(plugin::EventObserverList *observers)
  {
    session_event_observers= observers;
  }

  plugin::EventObserverList* getSchemaObservers(const std::string& schema);
  plugin::EventObserverList* setSchemaObservers(const std::string& schema, plugin::EventObserverList*);

public:
  void my_ok(ha_rows affected_rows= 0, ha_rows found_rows_arg= 0, uint64_t passed_id= 0, const char *message= __null);
  void my_eof();
  void add_item_to_list(Item *item);
  void add_value_to_list(Item *value);
  void add_order_to_list(Item *item, bool asc);
  void add_group_to_list(Item *item, bool asc);

  void refresh_status();
  user_var_entry* getVariable(str_ref name, bool create_if_not_exists);
  void setVariable(const std::string& name, const std::string& value);





  void close_thread_tables();
  void close_old_data_files(bool morph_locks= false, bool send_refresh= false);
  void close_data_files_and_morph_locks(const identifier::Table&);







  void close_tables_for_reopen(TableList **tables);
# 1007 "./drizzled/session.h"
  bool openTablesLock(TableList*);
  Table *open_temporary_table(const identifier::Table &identifier, bool link_in_list= true);

  int open_tables_from_list(TableList **start, uint32_t *counter, uint32_t flags= 0);

  Table *openTableLock(TableList *table_list, thr_lock_type lock_type);
  Table *openTable(TableList *table_list, bool *refresh, uint32_t flags= 0);

  void unlink_open_table(Table *find);
  void drop_open_table(Table *table, const identifier::Table &identifier);
  void close_cached_table(Table *table);


  table::Placeholder& table_cache_insert_placeholder(const identifier::Table&);
  Table* lock_table_name_if_not_cached(const identifier::Table&);

  session::TableMessages &getMessageCache();


  bool reopen_tables();
  bool close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders);

  void wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond);
  int setup_conds(TableList *leaves, COND **conds);
  int lock_tables(TableList *tables, uint32_t count, bool *need_reopen);

  template <class T>
  T* getProperty(const std::string& name)
  {
    return static_cast<T*>(getProperty0(name));
  }

  template <class T>
  T setProperty(const std::string& name, T value)
  {
    setProperty0(name, value);
    return value;
  }
# 1054 "./drizzled/session.h"
  plugin::StorageEngine *getDefaultStorageEngine();
  void get_xid(DrizzleXid *xid) const;

  table::Singular& getInstanceTable();
  table::Singular& getInstanceTable(std::list<CreateField>&);

  void setUsage(bool arg)
  {
    use_usage= arg;
  }

  const rusage &getUsage()
  {
    return usage;
  }

  const catalog::Instance& catalog() const
  {
    return *_catalog;
  }

  catalog::Instance& catalog()
  {
    return *_catalog;
  }

  bool arg_of_last_insert_id_function;
private:
  drizzled::util::Storable* getProperty0(const std::string&);
  void setProperty0(const std::string&, drizzled::util::Storable*);

  bool resetUsage()
  {
    return not getrusage(RUSAGE_THREAD, &usage);
  }

  boost::shared_ptr<catalog::Instance> _catalog;


  message::Transaction *transaction_message;
  message::Statement *statement_message;

  message::Resultset *resultset;
  plugin::EventObserverList *session_event_observers;

  uint64_t xa_id;
  const char *proc_info;
  bool abort_on_warning;
  bool concurrent_execute_allowed;
  bool tablespace_op;
  bool use_usage;
  rusage usage;
  identifier::user::mptr security_ctx;
  int32_t scoreboard_index;
  bool originating_server_uuid_set;
  std::string originating_server_uuid;
  uint64_t originating_commit_id;
  plugin::Client *client;
};





enum sql_command_flag_bits
{
  CF_BIT_CHANGES_DATA,
  CF_BIT_HAS_ROW_COUNT,
  CF_BIT_STATUS_COMMAND,
  CF_BIT_SHOW_TABLE_COMMAND,
  CF_BIT_WRITE_LOGS_COMMAND,
  CF_BIT_SIZE
};

static const std::bitset<CF_BIT_SIZE> CF_CHANGES_DATA(1 << CF_BIT_CHANGES_DATA);
static const std::bitset<CF_BIT_SIZE> CF_HAS_ROW_COUNT(1 << CF_BIT_HAS_ROW_COUNT);
static const std::bitset<CF_BIT_SIZE> CF_STATUS_COMMAND(1 << CF_BIT_STATUS_COMMAND);
static const std::bitset<CF_BIT_SIZE> CF_SHOW_TABLE_COMMAND(1 << CF_BIT_SHOW_TABLE_COMMAND);
static const std::bitset<CF_BIT_SIZE> CF_WRITE_LOGS_COMMAND(1 << CF_BIT_WRITE_LOGS_COMMAND);

namespace display
{
  const std::string &type(Session::global_read_lock_t);
  size_t max_string_length(Session::global_read_lock_t);
}

}
# 36 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/sql_lex.h" 1
# 20 "./drizzled/sql_lex.h"
       





# 1 "./drizzled/name_resolution_context.h" 1
# 20 "./drizzled/name_resolution_context.h"
       



namespace drizzled {
# 43 "./drizzled/name_resolution_context.h"
class Name_resolution_context : public memory::SqlAlloc
{
public:




  Name_resolution_context *outer_context;
# 60 "./drizzled/name_resolution_context.h"
  TableList *table_list;







  TableList *first_name_resolution_table;




  TableList *last_name_resolution_table;






  Select_Lex *select_lex;






  bool resolve_in_select_list;





  SecurityContext *security_ctx;

  Name_resolution_context()
    :
      outer_context(0),
      table_list(0),
      select_lex(0),
      security_ctx(0)
  {
  }

  inline void init()
  {
    resolve_in_select_list= false;
    first_name_resolution_table= __null;
    last_name_resolution_table= __null;
  }

  inline void resolve_in_table_list_only(TableList *tables)
  {
    table_list= first_name_resolution_table= tables;
    resolve_in_select_list= false;
  }
};

}
# 27 "./drizzled/sql_lex.h" 2
# 1 "./drizzled/table_list.h" 1
# 21 "./drizzled/table_list.h"
       

# 1 "./drizzled/nested_join.h" 1
# 20 "./drizzled/nested_join.h"
       







namespace drizzled {

class NestedJoin
{
public:



  NestedJoin()
  :
  join_list(),
  used_tables(),
  not_null_tables(),
  first_nested(__null),
  counter_(0),
  nj_map(),
  sj_depends_on(),
  sj_corr_tables(),
  sj_outer_expr_list()
  { }


  List<TableList> join_list;


  table_map used_tables;


  table_map not_null_tables;


  JoinTable *first_nested;
# 69 "./drizzled/nested_join.h"
  uint32_t counter_;


  std::bitset<64> nj_map;
# 83 "./drizzled/nested_join.h"
  bool is_fully_covered() const { return join_list.size() == counter_; }


  table_map getSjDependsOn() const
  {
    return sj_depends_on;
  }


  void setSjDependsOn(const table_map &in_sj_depends_on)
  {
    sj_depends_on= in_sj_depends_on;
  }


  table_map getSjCorrTables() const
  {
    return sj_corr_tables;
  }


  void setSjCorrTables(const table_map &in_sj_corr_tables)
  {
    sj_corr_tables= in_sj_corr_tables;
  }


  const List<Item>& getSjOuterExprList() const
  {
    return sj_outer_expr_list;
  }


  void setSjOuterExprList(const List<Item> &in_sj_outer_expr_list)
  {
    sj_outer_expr_list= in_sj_outer_expr_list;
  }

private:




  table_map sj_depends_on;


  table_map sj_corr_tables;

  List<Item> sj_outer_expr_list;

};

}
# 24 "./drizzled/table_list.h" 2
# 1 "./drizzled/table.h" 1
# 21 "./drizzled/table.h"
       


# 1 "/usr/include/boost/dynamic_bitset.hpp" 1 3 4
# 15 "/usr/include/boost/dynamic_bitset.hpp" 3 4
# 1 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 1 3 4
# 15 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 16 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 2 3 4




# 1 "/usr/include/c++/4.8/climits" 1 3 4
# 39 "/usr/include/c++/4.8/climits" 3 4
       
# 40 "/usr/include/c++/4.8/climits" 3

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include-fixed/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8/climits" 2 3
# 21 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 2 3 4

# 1 "/usr/include/boost/dynamic_bitset/config.hpp" 1 3 4
# 25 "/usr/include/boost/dynamic_bitset/config.hpp" 3 4
namespace boost { namespace detail {
    template <typename T> T make_non_const(T t) { return t; }
}}
# 23 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 2 3 4
# 36 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
# 1 "/usr/include/boost/dynamic_bitset_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/dynamic_bitset_fwd.hpp" 3 4
namespace boost {

template <typename Block = unsigned long,
          typename Allocator = std::allocator<Block> >
class dynamic_bitset;

}
# 37 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 2 3 4
# 1 "/usr/include/boost/detail/dynamic_bitset.hpp" 1 3 4
# 15 "/usr/include/boost/detail/dynamic_bitset.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstddef" 1 3 4
# 39 "/usr/include/c++/4.8/cstddef" 3 4
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 16 "/usr/include/boost/detail/dynamic_bitset.hpp" 2 3 4




namespace boost {

  namespace detail {
  namespace dynamic_bitset_impl {





    template <typename T>
    inline const unsigned char * object_representation (T* p)
    {
        return static_cast<const unsigned char *>(static_cast<const void *>(p));
    }

    template<typename T, int amount, int width >
    struct shifter
    {
        static void left_shift(T & v) {
            amount >= width ? (v = 0)
                : (v >>= (boost::detail::make_non_const(amount)));
        }
    };



    typedef unsigned char byte_type;
# 62 "/usr/include/boost/detail/dynamic_bitset.hpp" 3 4
    template <bool value>
    struct value_to_type
    {
        value_to_type() {}
    };
    const bool access_by_bytes = true;
    const bool access_by_blocks = false;





    template <bool dummy_name = true>
    struct count_table { static const byte_type table[]; };

    template <>
    struct count_table<false> { };


     const unsigned int table_width = 8;
     template <bool b>
     const byte_type count_table<b>::table[] =
     {


     0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
     1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
     1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
     2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
     1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
     2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
     2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
     3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
     };





     template <typename Iterator>
     inline std::size_t do_count(Iterator first, std::size_t length,
                                 int ,
                                 value_to_type<access_by_bytes>* )
     {
         std::size_t num = 0;
         if (length)
         {
             const byte_type * p = object_representation(&*first);
             length *= sizeof(*first);

              do {
                 num += count_table<>::table[*p];
                 ++p;
                 --length;

             } while (length);
         }

         return num;
     }




     template <typename Iterator, typename ValueType>
     inline std::size_t do_count(Iterator first, std::size_t length, ValueType,
                                 value_to_type<access_by_blocks>*)
     {
         std::size_t num = 0;
         while (length){

             ValueType value = *first;
             while (value) {
                 num += count_table<>::table[value & ((1u<<table_width) - 1)];
                 value >>= table_width;
             }

             ++first;
             --length;
         }

         return num;
     }
# 157 "/usr/include/boost/detail/dynamic_bitset.hpp" 3 4
    template <typename T>
    typename T::size_type vector_max_size_workaround(const T & v) {

      typedef typename T::allocator_type allocator_type;

      const typename allocator_type::size_type alloc_max =
                                                  v.get_allocator().max_size();
      const typename T::size_type container_max = v.max_size();

      return alloc_max < container_max?
                    alloc_max :
                    container_max;
    }


    template <typename T>
    struct allowed_block_type {
        enum { value = T(-1) > 0 };
    };

    template <>
    struct allowed_block_type<bool> {
        enum { value = false };
    };


    template <typename T>
    struct is_numeric {
        enum { value = false };
    };







    template<> struct is_numeric< bool > { enum { value = true }; };
    template<> struct is_numeric< char > { enum { value = true }; };


    template<> struct is_numeric< wchar_t > { enum { value = true }; };


    template<> struct is_numeric< signed char > { enum { value = true }; };
    template<> struct is_numeric< short int > { enum { value = true }; };
    template<> struct is_numeric< int > { enum { value = true }; };
    template<> struct is_numeric< long int > { enum { value = true }; };

    template<> struct is_numeric< unsigned char > { enum { value = true }; };
    template<> struct is_numeric< unsigned short > { enum { value = true }; };
    template<> struct is_numeric< unsigned int > { enum { value = true }; };
    template<> struct is_numeric< unsigned long > { enum { value = true }; };


    template<> struct is_numeric< ::boost::long_long_type > { enum { value = true }; };
    template<> struct is_numeric< ::boost::ulong_long_type > { enum { value = true }; };
# 223 "/usr/include/boost/detail/dynamic_bitset.hpp" 3 4
  }
  }

}
# 38 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 2 3 4



# 1 "/usr/include/boost/pending/lowest_bit.hpp" 1 3 4
# 17 "/usr/include/boost/pending/lowest_bit.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 18 "/usr/include/boost/pending/lowest_bit.hpp" 2 3 4
# 1 "/usr/include/boost/pending/integer_log2.hpp" 1 3 4
# 18 "/usr/include/boost/pending/integer_log2.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 19 "/usr/include/boost/pending/integer_log2.hpp" 2 3 4







namespace boost {
 namespace detail {

  template <typename T>
  int integer_log2_impl(T x, int n) {

      int result = 0;

      while (x != 1) {

          const T t = static_cast<T>(x >> n);
          if (t) {
              result += n;
              x = t;
          }
          n /= 2;

      }

      return result;
  }







  template <int p, int n>
  struct max_pow2_less {

      enum { c = 2*n < p };

      static const int value = c ? (max_pow2_less< c*p, 2*c*n>::value) : n
                                                      ;

  };

  template <>
  struct max_pow2_less<0, 0> {

      static const int value = 0;
  };






  template <typename T>
  struct width {




      static const int value = (std::numeric_limits<T>::digits);


  };

 }






 template <typename T>
 int integer_log2(T x) {

     ((x > 0) ? static_cast<void> (0) : __assert_fail ("x > 0", "/usr/include/boost/pending/integer_log2.hpp", 96, __PRETTY_FUNCTION__));

     const int n = detail::max_pow2_less<
                     detail::width<T> :: value, 4
                   > :: value;

     return detail::integer_log2_impl(x, n);

 }



}
# 19 "/usr/include/boost/pending/lowest_bit.hpp" 2 3 4


namespace boost {

    template <typename T>
    int lowest_bit(T x) {

        ((x >= 1) ? static_cast<void> (0) : __assert_fail ("x >= 1", "/usr/include/boost/pending/lowest_bit.hpp", 26, __PRETTY_FUNCTION__));




        return boost::integer_log2<T>( x - ( x & (x-1) ) );

    }


}
# 42 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 2 3 4


namespace boost {

template <typename Block, typename Allocator>
class dynamic_bitset
{
# 57 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((bool)detail::dynamic_bitset_impl::allowed_block_type<Block>::value) == 0 ? false : true) >)> boost_static_assert_typedef_57;

public:
    typedef Block block_type;
    typedef Allocator allocator_type;
    typedef std::size_t size_type;
    typedef block_type block_width_type;

    static const block_width_type bits_per_block = (std::numeric_limits<Block>::digits);
    static const size_type npos = static_cast<size_type>(-1);


public:



    class reference
    {
        friend class dynamic_bitset<Block, Allocator>;



        reference(block_type & b, block_type pos)
            :m_block(b),
             m_mask( (((pos < bits_per_block) ? static_cast<void> (0) : __assert_fail ("pos < bits_per_block", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 81, __PRETTY_FUNCTION__)),
                      block_type(1) << pos )
                   )
        { }

        void operator&();

    public:



        operator bool() const { return (m_block & m_mask) != 0; }
        bool operator~() const { return (m_block & m_mask) == 0; }

        reference& flip() { do_flip(); return *this; }

        reference& operator=(bool x) { do_assign(x); return *this; }
        reference& operator=(const reference& rhs) { do_assign(rhs); return *this; }

        reference& operator|=(bool x) { if (x) do_set(); return *this; }
        reference& operator&=(bool x) { if (!x) do_reset(); return *this; }
        reference& operator^=(bool x) { if (x) do_flip(); return *this; }
        reference& operator-=(bool x) { if (x) do_reset(); return *this; }

     private:
        block_type & m_block;
        const block_type m_mask;

        void do_set() { m_block |= m_mask; }
        void do_reset() { m_block &= ~m_mask; }
        void do_flip() { m_block ^= m_mask; }
        void do_assign(bool x) { x? do_set() : do_reset(); }
    };

    typedef bool const_reference;


    explicit
    dynamic_bitset(const Allocator& alloc = Allocator());

    explicit
    dynamic_bitset(size_type num_bits, unsigned long value = 0,
               const Allocator& alloc = Allocator());
# 137 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
    template <typename CharT, typename Traits, typename Alloc>
    dynamic_bitset(const std::basic_string<CharT, Traits, Alloc>& s,
        typename std::basic_string<CharT, Traits, Alloc>::size_type pos,
        typename std::basic_string<CharT, Traits, Alloc>::size_type n,
        size_type num_bits = npos,
        const Allocator& alloc = Allocator())

    :m_bits(alloc),
     m_num_bits(0)
    {
      init_from_string(s, pos, n, num_bits);
    }

    template <typename CharT, typename Traits, typename Alloc>
    explicit
    dynamic_bitset(const std::basic_string<CharT, Traits, Alloc>& s,
      typename std::basic_string<CharT, Traits, Alloc>::size_type pos = 0)

    :m_bits(Allocator()),
     m_num_bits(0)
    {
      init_from_string(s, pos, (std::basic_string<CharT, Traits, Alloc>::npos),
                       npos);
    }



    template <typename BlockInputIterator>
    dynamic_bitset(BlockInputIterator first, BlockInputIterator last,
                   const Allocator& alloc = Allocator())

    :m_bits(alloc),
     m_num_bits(0)
    {
        using boost::detail::dynamic_bitset_impl::value_to_type;
        using boost::detail::dynamic_bitset_impl::is_numeric;

        const value_to_type<
            is_numeric<BlockInputIterator>::value> selector;

        dispatch_init(first, last, selector);
    }

    template <typename T>
    void dispatch_init(T num_bits, unsigned long value,
                       detail::dynamic_bitset_impl::value_to_type<true>)
    {
        init_from_unsigned_long(static_cast<size_type>(num_bits), value);
    }

    template <typename T>
    void dispatch_init(T first, T last,
                       detail::dynamic_bitset_impl::value_to_type<false>)
    {
        init_from_block_range(first, last);
    }

    template <typename BlockIter>
    void init_from_block_range(BlockIter first, BlockIter last)
    {
        ((m_bits.size() == 0) ? static_cast<void> (0) : __assert_fail ("m_bits.size() == 0", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 197, __PRETTY_FUNCTION__));
        m_bits.insert(m_bits.end(), first, last);
        m_num_bits = m_bits.size() * bits_per_block;
    }


    dynamic_bitset(const dynamic_bitset& b);

    ~dynamic_bitset();

    void swap(dynamic_bitset& b);
    dynamic_bitset& operator=(const dynamic_bitset& b);

    allocator_type get_allocator() const;


    void resize(size_type num_bits, bool value = false);
    void clear();
    void push_back(bool bit);
    void append(Block block);

    template <typename BlockInputIterator>
    void m_append(BlockInputIterator first, BlockInputIterator last, std::input_iterator_tag)
    {
        std::vector<Block, Allocator> v(first, last);
        m_append(v.begin(), v.end(), std::random_access_iterator_tag());
    }
    template <typename BlockInputIterator>
    void m_append(BlockInputIterator first, BlockInputIterator last, std::forward_iterator_tag)
    {
        ((first != last) ? static_cast<void> (0) : __assert_fail ("first != last", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 227, __PRETTY_FUNCTION__));
        block_width_type r = count_extra_bits();
        std::size_t d = boost::detail::distance(first, last);
        m_bits.reserve(num_blocks() + d);
        if (r == 0) {
            for( ; first != last; ++first)
                m_bits.push_back(*first);
        }
        else {
            m_highest_block() |= (*first << r);
            do {
                Block b = *first >> (bits_per_block - r);
                ++first;
                m_bits.push_back(b | (first==last? 0 : *first << r));
            } while (first != last);
        }
        m_num_bits += bits_per_block * d;
    }
    template <typename BlockInputIterator>
    void append(BlockInputIterator first, BlockInputIterator last)
    {
        if (first != last) {
            typename detail::iterator_traits<BlockInputIterator>::iterator_category cat;
            m_append(first, last, cat);
        }
    }



    dynamic_bitset& operator&=(const dynamic_bitset& b);
    dynamic_bitset& operator|=(const dynamic_bitset& b);
    dynamic_bitset& operator^=(const dynamic_bitset& b);
    dynamic_bitset& operator-=(const dynamic_bitset& b);
    dynamic_bitset& operator<<=(size_type n);
    dynamic_bitset& operator>>=(size_type n);
    dynamic_bitset operator<<(size_type n) const;
    dynamic_bitset operator>>(size_type n) const;


    dynamic_bitset& set(size_type n, bool val = true);
    dynamic_bitset& set();
    dynamic_bitset& reset(size_type n);
    dynamic_bitset& reset();
    dynamic_bitset& flip(size_type n);
    dynamic_bitset& flip();
    bool test(size_type n) const;
    bool any() const;
    bool none() const;
    dynamic_bitset operator~() const;
    size_type count() const;


    reference operator[](size_type pos) {
        return reference(m_bits[block_index(pos)], bit_index(pos));
    }
    bool operator[](size_type pos) const { return test(pos); }

    unsigned long to_ulong() const;

    size_type size() const;
    size_type num_blocks() const;
    size_type max_size() const;
    bool empty() const;

    bool is_subset_of(const dynamic_bitset& a) const;
    bool is_proper_subset_of(const dynamic_bitset& a) const;
    bool intersects(const dynamic_bitset & a) const;


    size_type find_first() const;
    size_type find_next(size_type pos) const;




    template <typename B, typename A>
    friend bool operator==(const dynamic_bitset<B, A>& a,
                           const dynamic_bitset<B, A>& b);

    template <typename B, typename A>
    friend bool operator<(const dynamic_bitset<B, A>& a,
                          const dynamic_bitset<B, A>& b);


    template <typename B, typename A, typename BlockOutputIterator>
    friend void to_block_range(const dynamic_bitset<B, A>& b,
                               BlockOutputIterator result);

    template <typename BlockIterator, typename B, typename A>
    friend void from_block_range(BlockIterator first, BlockIterator last,
                                 dynamic_bitset<B, A>& result);


    template <typename CharT, typename Traits, typename B, typename A>
    friend std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is,
                                                         dynamic_bitset<B, A>& b);

    template <typename B, typename A, typename stringT>
    friend void to_string_helper(const dynamic_bitset<B, A> & b, stringT & s, bool dump_all);





private:
    static const block_width_type ulong_width = std::numeric_limits<unsigned long>::digits;
    typedef std::vector<block_type, allocator_type> buffer_type;

    void m_zero_unused_bits();
    bool m_check_invariants() const;

    size_type m_do_find_from(size_type first_block) const;

    block_width_type count_extra_bits() const { return bit_index(size()); }
    static size_type block_index(size_type pos) { return pos / bits_per_block; }
    static block_width_type bit_index(size_type pos) { return static_cast<block_width_type>(pos % bits_per_block); }
    static Block bit_mask(size_type pos) { return Block(1) << bit_index(pos); }

    template <typename CharT, typename Traits, typename Alloc>
    void init_from_string(const std::basic_string<CharT, Traits, Alloc>& s,
        typename std::basic_string<CharT, Traits, Alloc>::size_type pos,
        typename std::basic_string<CharT, Traits, Alloc>::size_type n,
        size_type num_bits)
    {
        ((pos <= s.size()) ? static_cast<void> (0) : __assert_fail ("pos <= s.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 351, __PRETTY_FUNCTION__));

        typedef typename std::basic_string<CharT, Traits, Alloc> StrT;
        typedef typename StrT::traits_type Tr;

        const typename StrT::size_type rlen = (std::min)(n, s.size() - pos);
        const size_type sz = ( num_bits != npos? num_bits : rlen);
        m_bits.resize(calc_num_blocks(sz));
        m_num_bits = sz;


        const std::ctype<CharT> & fac = std::use_facet< std::ctype<CharT> >(std::locale());
        const CharT one = (fac.widen('1'));

        const size_type m = num_bits < rlen ? num_bits : rlen;
        typename StrT::size_type i = 0;
        for( ; i < m; ++i) {

            const CharT c = s[(pos + m - 1) - i];

            ((Tr::eq(c, one) || Tr::eq(c, (fac.widen('0')))) ? static_cast<void> (0) : __assert_fail ("Tr::eq(c, one) || Tr::eq(c, (fac.widen('0')))",
 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp"
# 371 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
            ,
 372
# 371 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
            , __PRETTY_FUNCTION__))
                                                                             ;

            if (Tr::eq(c, one))
                set(i);

        }

    }

    void init_from_unsigned_long(size_type num_bits,
                                 unsigned long value
                                                         )
    {

        ((m_bits.size() == 0) ? static_cast<void> (0) : __assert_fail ("m_bits.size() == 0", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 386, __PRETTY_FUNCTION__));

        m_bits.resize(calc_num_blocks(num_bits));
        m_num_bits = num_bits;

        typedef unsigned long num_type;
        typedef boost::detail::dynamic_bitset_impl
            ::shifter<num_type, bits_per_block, ulong_width> shifter;






        if (num_bits < static_cast<size_type>(ulong_width)) {
            const num_type mask = (num_type(1) << num_bits) - 1;
            value &= mask;
        }

        typename buffer_type::iterator it = m_bits.begin();
        for( ; value; shifter::left_shift(value), ++it) {
            *it = static_cast<block_type>(value);
        }

    }



private:

    bool m_unchecked_test(size_type pos) const;
    static size_type calc_num_blocks(size_type num_bits);

    Block& m_highest_block();
    const Block& m_highest_block() const;

    buffer_type m_bits;
    size_type m_num_bits;


    class bit_appender;
    friend class bit_appender;
    class bit_appender {
# 438 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
      dynamic_bitset & bs;
      size_type n;
      Block mask;
      Block * current;


      bit_appender(const bit_appender &);
      bit_appender & operator=(const bit_appender &);

    public:
        bit_appender(dynamic_bitset & r) : bs(r), n(0), mask(0), current(0) {}
        ~bit_appender() {



            std::reverse(bs.m_bits.begin(), bs.m_bits.end());
            const block_width_type offs = bit_index(n);
            if (offs)
                bs >>= (bits_per_block - offs);
            bs.resize(n);
            ((bs.m_check_invariants()) ? static_cast<void> (0) : __assert_fail ("bs.m_check_invariants()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 458, __PRETTY_FUNCTION__));
        }
        inline void do_append(bool value) {

            if (mask == 0) {
                bs.append(Block(0));
                current = &bs.m_highest_block();
                mask = Block(1) << (bits_per_block - 1);
            }

            if(value)
                *current |= mask;

            mask /= 2;
            ++n;
        }
        size_type get_count() const { return n; }
    };

};



template <typename Block, typename Allocator>
const typename dynamic_bitset<Block, Allocator>::block_width_type
dynamic_bitset<Block, Allocator>::bits_per_block;

template <typename Block, typename Allocator>
const typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::npos;

template <typename Block, typename Allocator>
const typename dynamic_bitset<Block, Allocator>::block_width_type
dynamic_bitset<Block, Allocator>::ulong_width;






template <typename Block, typename Allocator>
bool operator!=(const dynamic_bitset<Block, Allocator>& a,
                const dynamic_bitset<Block, Allocator>& b);

template <typename Block, typename Allocator>
bool operator<=(const dynamic_bitset<Block, Allocator>& a,
                const dynamic_bitset<Block, Allocator>& b);

template <typename Block, typename Allocator>
bool operator>(const dynamic_bitset<Block, Allocator>& a,
               const dynamic_bitset<Block, Allocator>& b);

template <typename Block, typename Allocator>
bool operator>=(const dynamic_bitset<Block, Allocator>& a,
                const dynamic_bitset<Block, Allocator>& b);
# 523 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
template <typename CharT, typename Traits, typename Block, typename Allocator>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os,
           const dynamic_bitset<Block, Allocator>& b);

template <typename CharT, typename Traits, typename Block, typename Allocator>
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is,
           dynamic_bitset<Block, Allocator>& b);



template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator&(const dynamic_bitset<Block, Allocator>& b1,
          const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator|(const dynamic_bitset<Block, Allocator>& b1,
          const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator^(const dynamic_bitset<Block, Allocator>& b1,
          const dynamic_bitset<Block, Allocator>& b2);

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator-(const dynamic_bitset<Block, Allocator>& b1,
          const dynamic_bitset<Block, Allocator>& b2);


template<typename Block, typename Allocator>
void swap(dynamic_bitset<Block, Allocator>& b1,
          dynamic_bitset<Block, Allocator>& b2);


template <typename Block, typename Allocator, typename stringT>
void
to_string(const dynamic_bitset<Block, Allocator>& b, stringT & s);

template <typename Block, typename Allocator, typename BlockOutputIterator>
void
to_block_range(const dynamic_bitset<Block, Allocator>& b,
               BlockOutputIterator result);


template <typename BlockIterator, typename B, typename A>
inline void
from_block_range(BlockIterator first, BlockIterator last,
                 dynamic_bitset<B, A>& result)
{

    std::copy (first, last, result.m_bits.begin());
}
# 587 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>::dynamic_bitset(const Allocator& alloc)
  : m_bits(alloc), m_num_bits(0)
{

}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>::
dynamic_bitset(size_type num_bits, unsigned long value, const Allocator& alloc)
    : m_bits(alloc),
      m_num_bits(0)
{
    init_from_unsigned_long(num_bits, value);
}


template <typename Block, typename Allocator>
inline dynamic_bitset<Block, Allocator>::
dynamic_bitset(const dynamic_bitset& b)
  : m_bits(b.m_bits), m_num_bits(b.m_num_bits)
{

}

template <typename Block, typename Allocator>
inline dynamic_bitset<Block, Allocator>::
~dynamic_bitset()
{
    ((m_check_invariants()) ? static_cast<void> (0) : __assert_fail ("m_check_invariants()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 616, __PRETTY_FUNCTION__));
}

template <typename Block, typename Allocator>
inline void dynamic_bitset<Block, Allocator>::
swap(dynamic_bitset<Block, Allocator>& b)
{
    std::swap(m_bits, b.m_bits);
    std::swap(m_num_bits, b.m_num_bits);
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>& dynamic_bitset<Block, Allocator>::
operator=(const dynamic_bitset<Block, Allocator>& b)
{
    m_bits = b.m_bits;
    m_num_bits = b.m_num_bits;
    return *this;
}

template <typename Block, typename Allocator>
inline typename dynamic_bitset<Block, Allocator>::allocator_type
dynamic_bitset<Block, Allocator>::get_allocator() const
{
    return m_bits.get_allocator();
}




template <typename Block, typename Allocator>
void dynamic_bitset<Block, Allocator>::
resize(size_type num_bits, bool value)
{

  const size_type old_num_blocks = num_blocks();
  const size_type required_blocks = calc_num_blocks(num_bits);

  const block_type v = value? ~Block(0) : Block(0);

  if (required_blocks != old_num_blocks) {
    m_bits.resize(required_blocks, v);
  }
# 671 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
  if (value && (num_bits > m_num_bits)) {

    const block_width_type extra_bits = count_extra_bits();
    if (extra_bits) {
        ((old_num_blocks >= 1 && old_num_blocks <= m_bits.size()) ? static_cast<void> (0) : __assert_fail ("old_num_blocks >= 1 && old_num_blocks <= m_bits.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 675, __PRETTY_FUNCTION__));


        m_bits[old_num_blocks - 1] |= (v << extra_bits);
    }

  }

  m_num_bits = num_bits;
  m_zero_unused_bits();

}

template <typename Block, typename Allocator>
void dynamic_bitset<Block, Allocator>::
clear()
{
  m_bits.clear();
  m_num_bits = 0;
}


template <typename Block, typename Allocator>
void dynamic_bitset<Block, Allocator>::
push_back(bool bit)
{
  const size_type sz = size();
  resize(sz + 1);
  set(sz, bit);
}

template <typename Block, typename Allocator>
void dynamic_bitset<Block, Allocator>::
append(Block value)
{
    const block_width_type r = count_extra_bits();

    if (r == 0) {

        m_bits.push_back(value);
    }
    else {
        m_bits.push_back(value >> (bits_per_block - r));
        m_bits[m_bits.size() - 2] |= (value << r);
    }

    m_num_bits += bits_per_block;
    ((m_check_invariants()) ? static_cast<void> (0) : __assert_fail ("m_check_invariants()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 722, __PRETTY_FUNCTION__));

}




template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator&=(const dynamic_bitset& rhs)
{
    ((size() == rhs.size()) ? static_cast<void> (0) : __assert_fail ("size() == rhs.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 733, __PRETTY_FUNCTION__));
    for (size_type i = 0; i < num_blocks(); ++i)
        m_bits[i] &= rhs.m_bits[i];
    return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator|=(const dynamic_bitset& rhs)
{
    ((size() == rhs.size()) ? static_cast<void> (0) : __assert_fail ("size() == rhs.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 743, __PRETTY_FUNCTION__));
    for (size_type i = 0; i < num_blocks(); ++i)
        m_bits[i] |= rhs.m_bits[i];

    return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator^=(const dynamic_bitset& rhs)
{
    ((size() == rhs.size()) ? static_cast<void> (0) : __assert_fail ("size() == rhs.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 754, __PRETTY_FUNCTION__));
    for (size_type i = 0; i < this->num_blocks(); ++i)
        m_bits[i] ^= rhs.m_bits[i];

    return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator-=(const dynamic_bitset& rhs)
{
    ((size() == rhs.size()) ? static_cast<void> (0) : __assert_fail ("size() == rhs.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 765, __PRETTY_FUNCTION__));
    for (size_type i = 0; i < num_blocks(); ++i)
        m_bits[i] &= ~rhs.m_bits[i];

    return *this;
}







template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::operator<<=(size_type n)
{
    if (n >= m_num_bits)
        return reset();

    if (n > 0) {

        size_type const last = num_blocks() - 1;
        size_type const div = n / bits_per_block;
        block_width_type const r = bit_index(n);
        block_type * const b = &m_bits[0];

        if (r != 0) {

            block_width_type const rs = bits_per_block - r;

            for (size_type i = last-div; i>0; --i) {
                b[i+div] = (b[i] << r) | (b[i-1] >> rs);
            }
            b[div] = b[0] << r;

        }
        else {
            for (size_type i = last-div; i>0; --i) {
                b[i+div] = b[i];
            }
            b[div] = b[0];
        }


        std::fill_n(b, div, static_cast<block_type>(0));


        m_zero_unused_bits();

    }

    return *this;


}






template <typename B, typename A>
dynamic_bitset<B, A> & dynamic_bitset<B, A>::operator>>=(size_type n) {
    if (n >= m_num_bits) {
        return reset();
    }

    if (n>0) {

        size_type const last = num_blocks() - 1;
        size_type const div = n / bits_per_block;
        block_width_type const r = bit_index(n);
        block_type * const b = &m_bits[0];


        if (r != 0) {

            block_width_type const ls = bits_per_block - r;

            for (size_type i = div; i < last; ++i) {
                b[i-div] = (b[i] >> r) | (b[i+1] << ls);
            }

            b[last-div] = b[last] >> r;
        }

        else {
            for (size_type i = div; i <= last; ++i) {
                b[i-div] = b[i];
            }


        }




        std::fill_n(b + (num_blocks()-div), div, static_cast<block_type>(0));
    }

    return *this;
}


template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
dynamic_bitset<Block, Allocator>::operator<<(size_type n) const
{
    dynamic_bitset r(*this);
    return r <<= n;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
dynamic_bitset<Block, Allocator>::operator>>(size_type n) const
{
    dynamic_bitset r(*this);
    return r >>= n;
}





template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::set(size_type pos, bool val)
{
    ((pos < m_num_bits) ? static_cast<void> (0) : __assert_fail ("pos < m_num_bits", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 894, __PRETTY_FUNCTION__));

    if (val)
        m_bits[block_index(pos)] |= bit_mask(pos);
    else
        reset(pos);

    return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::set()
{
  std::fill(m_bits.begin(), m_bits.end(), ~Block(0));
  m_zero_unused_bits();
  return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::reset(size_type pos)
{
    ((pos < m_num_bits) ? static_cast<void> (0) : __assert_fail ("pos < m_num_bits", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 917, __PRETTY_FUNCTION__));






    m_bits[block_index(pos)] &= ~bit_mask(pos);

    return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::reset()
{
  std::fill(m_bits.begin(), m_bits.end(), Block(0));
  return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::flip(size_type pos)
{
    ((pos < m_num_bits) ? static_cast<void> (0) : __assert_fail ("pos < m_num_bits", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 941, __PRETTY_FUNCTION__));
    m_bits[block_index(pos)] ^= bit_mask(pos);
    return *this;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>&
dynamic_bitset<Block, Allocator>::flip()
{
    for (size_type i = 0; i < num_blocks(); ++i)
        m_bits[i] = ~m_bits[i];
    m_zero_unused_bits();
    return *this;
}

template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::m_unchecked_test(size_type pos) const
{
    return (m_bits[block_index(pos)] & bit_mask(pos)) != 0;
}

template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::test(size_type pos) const
{
    ((pos < m_num_bits) ? static_cast<void> (0) : __assert_fail ("pos < m_num_bits", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 965, __PRETTY_FUNCTION__));
    return m_unchecked_test(pos);
}

template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::any() const
{
    for (size_type i = 0; i < num_blocks(); ++i)
        if (m_bits[i])
            return true;
    return false;
}

template <typename Block, typename Allocator>
inline bool dynamic_bitset<Block, Allocator>::none() const
{
    return !any();
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
dynamic_bitset<Block, Allocator>::operator~() const
{
    dynamic_bitset b(*this);
    b.flip();
    return b;
}

template <typename Block, typename Allocator>
typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::count() const
{
    using detail::dynamic_bitset_impl::table_width;
    using detail::dynamic_bitset_impl::access_by_bytes;
    using detail::dynamic_bitset_impl::access_by_blocks;
    using detail::dynamic_bitset_impl::value_to_type;
# 1009 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
    enum { no_padding =
        dynamic_bitset<Block, Allocator>::bits_per_block
        == 8 * sizeof(Block) };


    enum { enough_table_width = table_width >= 8 };

    enum { mode = (no_padding && enough_table_width)
                          ? access_by_bytes
                          : access_by_blocks };

    return do_count(m_bits.begin(), num_blocks(), Block(0),
                    static_cast<value_to_type<(bool)mode> *>(0));
}






template <typename B, typename A, typename stringT>
void to_string_helper(const dynamic_bitset<B, A> & b, stringT & s,
                      bool dump_all)
{
    typedef typename stringT::traits_type Tr;
    typedef typename stringT::value_type Ch;

    const std::ctype<Ch> & fac = std::use_facet< std::ctype<Ch> >(std::locale());
    const Ch zero = (fac.widen('0'));
    const Ch one = (fac.widen('1'));




    typedef typename dynamic_bitset<B, A>::size_type size_type;

    const size_type len = dump_all?
         dynamic_bitset<B, A>::bits_per_block * b.num_blocks():
         b.size();
    s.assign (len, zero);

    for (size_type i = 0; i < len; ++i) {
        if (b.m_unchecked_test(i))
            Tr::assign(s[len - 1 - i], one);

    }

}







template <typename Block, typename Allocator, typename stringT>
inline void
to_string(const dynamic_bitset<Block, Allocator>& b, stringT& s)
{
    to_string_helper(b, s, false);
}






template <typename B, typename A, typename stringT>
inline void
dump_to_string(const dynamic_bitset<B, A>& b, stringT& s)
{
    to_string_helper(b, s, true );
}

template <typename Block, typename Allocator, typename BlockOutputIterator>
inline void
to_block_range(const dynamic_bitset<Block, Allocator>& b,
               BlockOutputIterator result)
{


    std::copy(b.m_bits.begin(), b.m_bits.end(), result);
}

template <typename Block, typename Allocator>
unsigned long dynamic_bitset<Block, Allocator>::
to_ulong() const
{

  if (m_num_bits == 0)
      return 0;



  if (find_next(ulong_width - 1) != npos)
    throw std::overflow_error("boost::dynamic_bitset::to_ulong overflow");




  typedef unsigned long result_type;

  const size_type maximum_size =
            (std::min)(m_num_bits, static_cast<size_type>(ulong_width));

  const size_type last_block = block_index( maximum_size - 1 );

  (((last_block * bits_per_block) < static_cast<size_type>(ulong_width)) ? static_cast<void> (0) : __assert_fail ("(last_block * bits_per_block) < static_cast<size_type>(ulong_width)", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1116, __PRETTY_FUNCTION__));

  result_type result = 0;
  for (size_type i = 0; i <= last_block; ++i) {
    const size_type offset = i * bits_per_block;
    result |= (static_cast<result_type>(m_bits[i]) << offset);
  }

  return result;
}

template <typename Block, typename Allocator>
inline typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::size() const
{
    return m_num_bits;
}

template <typename Block, typename Allocator>
inline typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::num_blocks() const
{
    return m_bits.size();
}

template <typename Block, typename Allocator>
inline typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::max_size() const
{
# 1155 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
    const size_type m = detail::dynamic_bitset_impl::
                        vector_max_size_workaround(m_bits);

    return m <= (size_type(-1)/bits_per_block) ?
        m * bits_per_block :
        size_type(-1);
}

template <typename Block, typename Allocator>
inline bool dynamic_bitset<Block, Allocator>::empty() const
{
  return size() == 0;
}

template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::
is_subset_of(const dynamic_bitset<Block, Allocator>& a) const
{
    ((size() == a.size()) ? static_cast<void> (0) : __assert_fail ("size() == a.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1173, __PRETTY_FUNCTION__));
    for (size_type i = 0; i < num_blocks(); ++i)
        if (m_bits[i] & ~a.m_bits[i])
            return false;
    return true;
}

template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::
is_proper_subset_of(const dynamic_bitset<Block, Allocator>& a) const
{
    ((size() == a.size()) ? static_cast<void> (0) : __assert_fail ("size() == a.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1184, __PRETTY_FUNCTION__));
    ((num_blocks() == a.num_blocks()) ? static_cast<void> (0) : __assert_fail ("num_blocks() == a.num_blocks()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1185, __PRETTY_FUNCTION__));

    bool proper = false;
    for (size_type i = 0; i < num_blocks(); ++i) {
        const Block & bt = m_bits[i];
        const Block & ba = a.m_bits[i];

        if (bt & ~ba)
            return false;
        if (ba & ~bt)
            proper = true;
    }
    return proper;
}

template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::intersects(const dynamic_bitset & b) const
{
    size_type common_blocks = num_blocks() < b.num_blocks()
                              ? num_blocks() : b.num_blocks();

    for(size_type i = 0; i < common_blocks; ++i) {
        if(m_bits[i] & b.m_bits[i])
            return true;
    }
    return false;
}
# 1220 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
template <typename Block, typename Allocator>
typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::m_do_find_from(size_type first_block) const
{
    size_type i = first_block;


    while (i < num_blocks() && m_bits[i] == 0)
        ++i;

    if (i >= num_blocks())
        return npos;

    return i * bits_per_block + boost::lowest_bit(m_bits[i]);

}


template <typename Block, typename Allocator>
typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::find_first() const
{
    return m_do_find_from(0);
}


template <typename Block, typename Allocator>
typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::find_next(size_type pos) const
{

    const size_type sz = size();
    if (pos >= (sz-1) || sz == 0)
        return npos;

    ++pos;

    const size_type blk = block_index(pos);
    const block_width_type ind = bit_index(pos);


    const Block fore = m_bits[blk] & ( ~Block(0) << ind );

    return fore?
        blk * bits_per_block + lowest_bit(fore)
        :
        m_do_find_from(blk + 1);

}






template <typename Block, typename Allocator>
bool operator==(const dynamic_bitset<Block, Allocator>& a,
                const dynamic_bitset<Block, Allocator>& b)
{
    return (a.m_num_bits == b.m_num_bits)
           && (a.m_bits == b.m_bits);
}

template <typename Block, typename Allocator>
inline bool operator!=(const dynamic_bitset<Block, Allocator>& a,
                       const dynamic_bitset<Block, Allocator>& b)
{
    return !(a == b);
}

template <typename Block, typename Allocator>
bool operator<(const dynamic_bitset<Block, Allocator>& a,
               const dynamic_bitset<Block, Allocator>& b)
{
    ((a.size() == b.size()) ? static_cast<void> (0) : __assert_fail ("a.size() == b.size()", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1294, __PRETTY_FUNCTION__));
    typedef typename dynamic_bitset<Block, Allocator>::size_type size_type;







    for (size_type ii = a.num_blocks(); ii > 0; --ii) {
      size_type i = ii-1;
      if (a.m_bits[i] < b.m_bits[i])
        return true;
      else if (a.m_bits[i] > b.m_bits[i])
        return false;
    }
    return false;
}

template <typename Block, typename Allocator>
inline bool operator<=(const dynamic_bitset<Block, Allocator>& a,
                       const dynamic_bitset<Block, Allocator>& b)
{
    return !(a > b);
}

template <typename Block, typename Allocator>
inline bool operator>(const dynamic_bitset<Block, Allocator>& a,
                      const dynamic_bitset<Block, Allocator>& b)
{
    return b < a;
}

template <typename Block, typename Allocator>
inline bool operator>=(const dynamic_bitset<Block, Allocator>& a,
                       const dynamic_bitset<Block, Allocator>& b)
{
    return !(a < b);
}
# 1407 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
template <typename Ch, typename Tr, typename Block, typename Alloc>
std::basic_ostream<Ch, Tr>&
operator<<(std::basic_ostream<Ch, Tr>& os,
           const dynamic_bitset<Block, Alloc>& b)
{

    using namespace std;

    const ios_base::iostate ok = ios_base::goodbit;
    ios_base::iostate err = ok;

    typename basic_ostream<Ch, Tr>::sentry cerberos(os);
    if (cerberos) {

        const std::ctype<Ch> & fac = std::use_facet< std::ctype<Ch> >(os.getloc());
        const Ch zero = (fac.widen('0'));
        const Ch one = (fac.widen('1'));

        try {

            typedef typename dynamic_bitset<Block, Alloc>::size_type bitsetsize_type;
            typedef basic_streambuf<Ch, Tr> buffer_type;

            buffer_type * buf = os.rdbuf();
            size_t npad = os.width() <= 0
                || (bitsetsize_type) os.width() <= b.size()? 0 : os.width() - b.size();

            const Ch fill_char = os.fill();
            const ios_base::fmtflags adjustfield = os.flags() & ios_base::adjustfield;


            if (adjustfield != ios_base::left) {
                for (; 0 < npad; --npad)
                    if (Tr::eq_int_type(Tr::eof(), buf->sputc(fill_char))) {
                          err |= ios_base::failbit;
                          break;
                    }
            }

            if (err == ok) {

                for (bitsetsize_type i = b.size(); 0 < i; --i) {
                    typename buffer_type::int_type
                        ret = buf->sputc(b.test(i-1)? one : zero);
                    if (Tr::eq_int_type(Tr::eof(), ret)) {
                        err |= ios_base::failbit;
                        break;
                    }
                }
            }

            if (err == ok) {

                for (; 0 < npad; --npad) {
                    if (Tr::eq_int_type(Tr::eof(), buf->sputc(fill_char))) {
                        err |= ios_base::failbit;
                        break;
                    }
                }
            }


            os.width(0);

        } catch (...) {
            bool rethrow = false;
            try { os.setstate(ios_base::failbit); } catch (...) { rethrow = true; }

            if (rethrow)
                throw;
        }
    }

    if(err != ok)
        os.setstate(err);
    return os;

}
# 1559 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
template <typename Ch, typename Tr, typename Block, typename Alloc>
std::basic_istream<Ch, Tr>&
operator>>(std::basic_istream<Ch, Tr>& is, dynamic_bitset<Block, Alloc>& b)
{

    using namespace std;

    typedef dynamic_bitset<Block, Alloc> bitset_type;
    typedef typename bitset_type::size_type size_type;

    const streamsize w = is.width();
    const size_type limit = 0 < w && static_cast<size_type>(w) < b.max_size()?
                                         w : b.max_size();

    ios_base::iostate err = ios_base::goodbit;
    typename basic_istream<Ch, Tr>::sentry cerberos(is);
    if(cerberos) {


        const std::ctype<Ch> & fac = std::use_facet< std::ctype<Ch> >(is.getloc());
        const Ch zero = (fac.widen('0'));
        const Ch one = (fac.widen('1'));

        b.clear();
        try {
            typename bitset_type::bit_appender appender(b);
            basic_streambuf <Ch, Tr> * buf = is.rdbuf();
            typename Tr::int_type c = buf->sgetc();
            for( ; appender.get_count() < limit; c = buf->snextc() ) {

                if (Tr::eq_int_type(Tr::eof(), c)) {
                    err |= ios_base::eofbit;
                    break;
                }
                else {
                    const Ch to_c = Tr::to_char_type(c);
                    const bool is_one = Tr::eq(to_c, one);

                    if (!is_one && !Tr::eq(to_c, zero))
                        break;

                    appender.do_append(is_one);

                }

            }
        }
        catch (...) {






            bool rethrow = false;
            try { is.setstate(ios_base::badbit); }
            catch(...) { rethrow = true; }

            if (rethrow)
                throw;

        }
    }

    is.width(0);
    if (b.size() == 0 )
        err |= ios_base::failbit;
    if (err != ios_base::goodbit)
        is.setstate (err);

    return is;

}
# 1640 "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp" 3 4
template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator&(const dynamic_bitset<Block, Allocator>& x,
          const dynamic_bitset<Block, Allocator>& y)
{
    dynamic_bitset<Block, Allocator> b(x);
    return b &= y;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator|(const dynamic_bitset<Block, Allocator>& x,
          const dynamic_bitset<Block, Allocator>& y)
{
    dynamic_bitset<Block, Allocator> b(x);
    return b |= y;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator^(const dynamic_bitset<Block, Allocator>& x,
          const dynamic_bitset<Block, Allocator>& y)
{
    dynamic_bitset<Block, Allocator> b(x);
    return b ^= y;
}

template <typename Block, typename Allocator>
dynamic_bitset<Block, Allocator>
operator-(const dynamic_bitset<Block, Allocator>& x,
          const dynamic_bitset<Block, Allocator>& y)
{
    dynamic_bitset<Block, Allocator> b(x);
    return b -= y;
}




template<typename Block, typename Allocator>
inline void
swap(dynamic_bitset<Block, Allocator>& left,
     dynamic_bitset<Block, Allocator>& right)
{
    left.swap(right);
}






template <typename Block, typename Allocator>
inline typename dynamic_bitset<Block, Allocator>::size_type
dynamic_bitset<Block, Allocator>::calc_num_blocks(size_type num_bits)
{
    return num_bits / bits_per_block
           + static_cast<int>( num_bits % bits_per_block != 0 );
}



template <typename Block, typename Allocator>
inline Block& dynamic_bitset<Block, Allocator>::m_highest_block()
{
    return const_cast<Block &>
           (static_cast<const dynamic_bitset *>(this)->m_highest_block());
}



template <typename Block, typename Allocator>
inline const Block& dynamic_bitset<Block, Allocator>::m_highest_block() const
{
    ((size() > 0 && num_blocks() > 0) ? static_cast<void> (0) : __assert_fail ("size() > 0 && num_blocks() > 0", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1714, __PRETTY_FUNCTION__));
    return m_bits.back();
}







template <typename Block, typename Allocator>
inline void dynamic_bitset<Block, Allocator>::m_zero_unused_bits()
{
    ((num_blocks() == calc_num_blocks(m_num_bits)) ? static_cast<void> (0) : __assert_fail ("num_blocks() == calc_num_blocks(m_num_bits)", "/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp", 1727, __PRETTY_FUNCTION__));


    const block_width_type extra_bits = count_extra_bits();

    if (extra_bits != 0)
        m_highest_block() &= ~(~static_cast<Block>(0) << extra_bits);

}


template <typename Block, typename Allocator>
bool dynamic_bitset<Block, Allocator>::m_check_invariants() const
{
    const block_width_type extra_bits = count_extra_bits();
    if (extra_bits > 0) {
        block_type const mask = (~static_cast<Block>(0) << extra_bits);
        if ((m_highest_block() & mask) != 0)
            return false;
    }
    if (m_bits.size() > m_bits.capacity() || num_blocks() != calc_num_blocks(size()))
        return false;

    return true;

}


}
# 16 "/usr/include/boost/dynamic_bitset.hpp" 2 3 4
# 25 "./drizzled/table.h" 2

# 1 "./drizzled/order.h" 1
# 20 "./drizzled/order.h"
       

# 1 "./drizzled/field.h" 1
# 27 "./drizzled/field.h"
       




# 1 "./drizzled/key_map.h" 1
# 20 "./drizzled/key_map.h"
       







namespace drizzled
{



typedef std::bitset<72> key_map;





extern const key_map key_map_empty;
extern __attribute__ ((visibility("default"))) key_map key_map_full;

bool is_keymap_prefix(const key_map& map, const uint32_t n);
bool is_overlapping(const key_map& map, const key_map& map2);
void set_prefix(key_map& map, const uint32_t n);
void key_map_subtract(key_map& map1, key_map& map2);

}
# 33 "./drizzled/field.h" 2

# 1 "./drizzled/structs.h" 1
# 21 "./drizzled/structs.h"
       






namespace drizzled {

class KeyPartInfo
{
public:
  Field *field;
  unsigned int offset;
  unsigned int null_offset;

  uint16_t length;
# 46 "./drizzled/structs.h"
  uint16_t store_length;
  uint16_t key_type;
private:
public:
  uint16_t getKeyType() const
  {
    return key_type;
  }
  uint16_t fieldnr;
  uint16_t key_part_flag;
  uint8_t type;
  uint8_t null_bit;
};


class KeyInfo
{
public:
  unsigned int key_length;
  enum ha_key_alg algorithm;
  unsigned long flags;
  unsigned int key_parts;
  uint32_t extra_length;
  unsigned int usable_key_parts;
  uint32_t block_size;
  KeyPartInfo *key_part;
  const char* name;





  ulong *rec_per_key;
  Table *table;
  str_ref comment;
};


class RegInfo
{
public:
  JoinTable *join_tab;
  enum thr_lock_type lock_type;
  bool not_exists_optimize;
  bool impossible_range;
  RegInfo()
    : join_tab(__null), lock_type(TL_UNLOCK),
      not_exists_optimize(false), impossible_range(false) {}
  void reset()
  {
    join_tab= __null;
    lock_type= TL_UNLOCK;
    not_exists_optimize= false;
    impossible_range= false;
  }
};

typedef int *(*update_var)(Session *, struct drizzle_show_var *);

}
# 35 "./drizzled/field.h" 2
# 43 "./drizzled/field.h"
namespace drizzled {







const uint32_t max_field_size= (uint32_t) 4294967295U;

int field_conv(Field *to,Field *from);
# 68 "./drizzled/field.h"
class __attribute__ ((visibility("default"))) Field : boost::noncopyable
{
public:
  unsigned char *ptr;
  unsigned char *null_ptr;







private:
  Table *table;

public:
  Table *getTable()
  {
    ((table) ? static_cast<void> (0) : __assert_fail ("table", "./drizzled/field.h", 86, __PRETTY_FUNCTION__));
    return table;
  }

  Table *getTable() const
  {
    ((table) ? static_cast<void> (0) : __assert_fail ("table", "./drizzled/field.h", 92, __PRETTY_FUNCTION__));
    return table;
  }

  void setTable(Table *table_arg)
  {
    table= table_arg;
  }

  Table *orig_table;
  const char *field_name;
  str_ref comment;


  key_map key_start;
  key_map part_of_key;
  key_map part_of_key_not_clustered;
  key_map part_of_sortkey;
# 118 "./drizzled/field.h"
  enum utype
  {
    NONE,
    NEXT_NUMBER,
    TIMESTAMP_OLD_FIELD,
    TIMESTAMP_DN_FIELD,
    TIMESTAMP_UN_FIELD,
    TIMESTAMP_DNUN_FIELD
  };

  utype unireg_check;
  uint32_t field_length;
  uint32_t flags;

  bool isUnsigned() const
  {
    return flags & 32;
  }

private:
  uint16_t field_index;

public:

  uint16_t position() const
  {
    return field_index;
  }

  void setPosition(uint32_t arg)
  {
    field_index= arg;
  }

  unsigned char null_bit;
# 161 "./drizzled/field.h"
  bool is_created_from_null_item;

  static void *operator new(size_t size);
  static void *operator new(size_t size, memory::Root *mem_root);
  static void operator delete(void *, size_t)
  { }
  static void operator delete(void *, memory::Root *)
  { }

  Field(unsigned char *ptr_arg,
        uint32_t length_arg,
        unsigned char *null_ptr_arg,
        unsigned char null_bit_arg,
        utype unireg_check_arg,
        const char *field_name_arg);
  virtual ~Field() {}

  bool hasDefault() const
  {
    return not (flags & 4096);
  }


  virtual int store(const char *to,
                    uint32_t length,
                    const charset_info_st * const cs)=0;
  virtual int store(double nr)=0;
  virtual int store(int64_t nr, bool unsigned_val)=0;
  virtual int store_decimal(const type::Decimal *d)=0;
  int store_and_check(enum_check_fields check_level,
                      const char *to,
                      uint32_t length,
                      const charset_info_st * const cs);






  virtual int store_time(type::Time &ltime, type::timestamp_t t_type);
  virtual double val_real() const=0;
  virtual int64_t val_int() const =0;
  virtual type::Decimal *val_decimal(type::Decimal *) const;
  String *val_str_internal(String *str) const
  {
    return val_str(str, str);
  }
# 221 "./drizzled/field.h"
  virtual String *val_str(String*, String *) const =0;





  virtual bool str_needs_quotes() { return false; }
  virtual Item_result result_type () const=0;
  virtual Item_result cmp_type () const { return result_type(); }
  virtual Item_result cast_to_int_type () const { return result_type(); }
# 245 "./drizzled/field.h"
  static bool type_can_have_key_part(enum_field_types);
# 255 "./drizzled/field.h"
  static enum_field_types field_type_merge(enum_field_types, enum_field_types);
# 265 "./drizzled/field.h"
  static Item_result result_merge_type(enum_field_types);

  virtual bool eq(Field *field);
# 276 "./drizzled/field.h"
  virtual bool eq_def(Field *field);

  virtual bool is_timestamp() const
  {
    return false;
  }






  virtual uint32_t pack_length() const;






  virtual uint32_t pack_length_in_rec() const;





  virtual uint32_t data_length();





  virtual uint32_t used_length();
  virtual uint32_t sort_length() const;







  virtual uint32_t max_data_length() const;
  virtual int reset(void);
  virtual void reset_fields();
  virtual void set_default();
  virtual bool binary() const;
  virtual bool zero_pack() const;
  virtual enum ha_base_keytype key_type() const;
  virtual uint32_t key_length() const;
  virtual enum_field_types type() const =0;
  virtual enum_field_types real_type() const;
  virtual int cmp_max(const unsigned char *a, const unsigned char *b, uint32_t max_len);
  virtual int cmp(const unsigned char *,const unsigned char *)=0;
  int cmp_internal(const unsigned char *str) { return cmp(ptr,str); }
  virtual int cmp_binary(const unsigned char *a,const unsigned char *b,
                         uint32_t max_length=(4294967295U));
  virtual int cmp_offset(uint32_t row_offset);
  virtual int cmp_binary_offset(uint32_t row_offset);
  virtual int key_cmp(const unsigned char *a,const unsigned char *b);
  virtual int key_cmp(const unsigned char *str, uint32_t length);
  virtual uint32_t decimals() const;


  virtual uint32_t size_of() const =0;

  bool is_null(ptrdiff_t row_offset= 0) const;
  bool is_real_null(ptrdiff_t row_offset= 0) const;
  bool is_null_in_record(const unsigned char *record) const;
  bool is_null_in_record_with_offset(ptrdiff_t offset) const;
  void set_null(ptrdiff_t row_offset= 0);
  void set_notnull(ptrdiff_t row_offset= 0);
  bool maybe_null(void) const;
  bool real_maybe_null(void) const;

  virtual void make_field(SendField *);
  virtual void sort_string(unsigned char *buff,uint32_t length)=0;
  virtual bool optimize_range(uint32_t idx, uint32_t part);







  virtual bool can_be_compared_as_int64_t() const
  {
    return false;
  }
  virtual void free() {}
  virtual Field *new_field(memory::Root*, Table*, bool keep_type);
  virtual Field *new_key_field(memory::Root *root, Table *new_table,
                               unsigned char *new_ptr,
                               unsigned char *new_null_ptr,
                               uint32_t new_null_bit);

  Field* clone(memory::Root*, Table*);
  void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)
  {
    ptr= ptr_arg;
    null_ptr= null_ptr_arg;
    null_bit= null_bit_arg;
  }
  void move_field(unsigned char *ptr_arg) { ptr=ptr_arg; }
  virtual void move_field_offset(ptrdiff_t ptr_diff)
  {
    ptr= (unsigned char*) (reinterpret_cast<const unsigned char*>(ptr)+ptr_diff);
    if (null_ptr)
      null_ptr= (unsigned char*) (reinterpret_cast<const unsigned char*>(null_ptr)+ptr_diff);
  }
  virtual void get_image(unsigned char *buff, uint32_t length, const charset_info_st * const)
  {
    memcpy(buff,ptr,length);
  }
  virtual void get_image(std::basic_string<unsigned char> &buff, uint32_t length, const charset_info_st * const)
  {
    buff.append(ptr,length);
  }
  virtual void set_image(const unsigned char *buff,uint32_t length, const charset_info_st * const)
  {
    memcpy(ptr,buff,length);
  }
# 421 "./drizzled/field.h"
  virtual uint32_t get_key_image(unsigned char *buff, uint32_t length)
  {
    get_image(buff, length, &my_charset_bin);
    return length;
  }
  virtual uint32_t get_key_image(std::basic_string<unsigned char> &buff, uint32_t length)
  {
    get_image(buff, length, &my_charset_bin);
    return length;
  }
  virtual void set_key_image(const unsigned char *buff,uint32_t length)
  {
    set_image(buff,length, &my_charset_bin);
  }
  int64_t val_int_offset(uint32_t row_offset)
  {
    ptr+=row_offset;
    int64_t tmp=val_int();
    ptr-=row_offset;
    return tmp;
  }

  int64_t val_int_internal(const unsigned char *new_ptr)
  {
    unsigned char *old_ptr= ptr;
    ptr= const_cast<unsigned char*>(new_ptr);
    int64_t return_value= val_int();
    ptr= old_ptr;
    return return_value;
  }

  String *val_str_internal(String *str, const unsigned char *new_ptr)
  {
    unsigned char *old_ptr= ptr;
    ptr= const_cast<unsigned char*>(new_ptr);
    val_str_internal(str);
    ptr= old_ptr;
    return str;
  }
# 498 "./drizzled/field.h"
  virtual unsigned char *pack(unsigned char *to,
                              const unsigned char *from,
                              uint32_t max_length,
                              bool low_byte_first);

  unsigned char *pack(unsigned char *to, const unsigned char *from);
# 535 "./drizzled/field.h"
  virtual const unsigned char *unpack(unsigned char* to,
                                      const unsigned char *from,
                                      uint32_t param_data,
                                      bool low_byte_first);




  const unsigned char *unpack(unsigned char* to,
                              const unsigned char *from);

  virtual unsigned char *pack_key(unsigned char* to,
                                  const unsigned char *from,
                                  uint32_t max_length,
                                  bool low_byte_first)
  {
    return pack(to, from, max_length, low_byte_first);
  }
  virtual const unsigned char *unpack_key(unsigned char* to,
                                          const unsigned char *from,
                                          uint32_t max_length,
                                          bool low_byte_first)
  {
    return unpack(to, from, max_length, low_byte_first);
  }
  virtual uint32_t max_packed_col_length(uint32_t max_length)
  {
    return max_length;
  }

  uint32_t offset(const unsigned char *record)
  {
    return (uint32_t) (ptr - record);
  }
  void copy_from_tmp(int offset);
  uint32_t fill_cache_field(CacheField *copy);
  virtual bool get_date(type::Time &ltime,uint32_t fuzzydate) const;
  virtual bool get_time(type::Time &ltime) const;
  virtual const charset_info_st *charset(void) const { return &my_charset_bin; }
  virtual const charset_info_st *sort_charset(void) const { return charset(); }
  virtual bool has_charset(void) const { return false; }
  virtual void set_charset(const charset_info_st * const)
  {}
  virtual enum Derivation derivation(void) const
  {
    return DERIVATION_IMPLICIT;
  }
  virtual void set_derivation(enum Derivation)
  {}
# 603 "./drizzled/field.h"
  bool set_warning(DRIZZLE_ERROR::enum_warning_level,
                   drizzled::error_t code,
                   int cuted_increment);
# 621 "./drizzled/field.h"
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
                            drizzled::error_t code,
                            const char *str,
                            uint32_t str_len,
                            type::timestamp_t ts_type,
                            int cuted_increment);
# 641 "./drizzled/field.h"
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
                            drizzled::error_t code,
                            int64_t nr,
                            type::timestamp_t ts_type,
                            int cuted_increment);
# 659 "./drizzled/field.h"
  void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level,
                            const drizzled::error_t code,
                            double nr,
                            type::timestamp_t ts_type);
  bool check_overflow(int op_result)
  {
    return (op_result == 2);
  }
# 679 "./drizzled/field.h"
  int warn_if_overflow(int op_result);
  void init(Table *table_arg);


  virtual uint32_t max_display_length()= 0;

  virtual uint32_t is_equal(CreateField *new_field);
# 697 "./drizzled/field.h"
  int64_t convert_decimal2int64_t(const type::Decimal *val,
                                  bool unsigned_flag,
                                  int *err);

  uint32_t char_length() const
  {
    return field_length / charset()->mbmaxlen;
  }

  enum column_format_type column_format() const
  {
    return (enum column_format_type)
      ((flags >> 25) & 7);
  }


  virtual void hash(uint32_t *nr, uint32_t *nr2) const;
  friend bool reopen_table(Session *,Table *,bool);

  friend class CopyField;
  friend class Item_avg_field;
  friend class Item_std_field;
  friend class Item_sum_num;
  friend class Item_sum_sum;
  friend class Item_sum_str;
  friend class Item_sum_count;
  friend class Item_sum_avg;
  friend class Item_sum_std;
  friend class Item_sum_min;
  friend class Item_sum_max;
  friend class Item_func_group_concat;

  bool isReadSet() const;
  bool isWriteSet();
  void setReadSet(bool arg= true);
  void setWriteSet(bool arg= true);

protected:

  void pack_num(uint64_t arg, unsigned char *destination= __null);
  void pack_num(uint32_t arg, unsigned char *destination= __null);
  uint64_t unpack_num(uint64_t &destination, const unsigned char *arg= __null) const;
  uint32_t unpack_num(uint32_t &destination, const unsigned char *arg= __null) const;
};

namespace field {

inline bool isDateTime(const enum_field_types &arg)
{
  switch (arg)
  {
  case DRIZZLE_TYPE_DATE:
  case DRIZZLE_TYPE_DATETIME:
  case DRIZZLE_TYPE_MICROTIME:
  case DRIZZLE_TYPE_TIME:
  case DRIZZLE_TYPE_TIMESTAMP:
    return true;

  case DRIZZLE_TYPE_BLOB:
  case DRIZZLE_TYPE_BOOLEAN:
  case DRIZZLE_TYPE_DECIMAL:
  case DRIZZLE_TYPE_DOUBLE:
  case DRIZZLE_TYPE_ENUM:
  case DRIZZLE_TYPE_LONG:
  case DRIZZLE_TYPE_LONGLONG:
  case DRIZZLE_TYPE_NULL:
  case DRIZZLE_TYPE_UUID:
  case DRIZZLE_TYPE_IPV6:
  case DRIZZLE_TYPE_VARCHAR:
    return false;
  }

  ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/field.h", 769, __PRETTY_FUNCTION__));
  abort();
}

}

std::ostream& operator<<(std::ostream& output, const Field &field);
# 785 "./drizzled/field.h"
class SendField
{
public:
  const char *db_name;
  const char *table_name;
  const char *org_table_name;
  const char *col_name;
  const char *org_col_name;
  uint32_t length;
  uint32_t charsetnr;
  uint32_t flags;
  uint32_t decimals;
  enum_field_types type;
};

uint32_t pack_length_to_packflag(uint32_t type);
uint32_t calc_pack_length(enum_field_types type,uint32_t length);
int set_field_to_null(Field *field);
int set_field_to_null_with_conversions(Field *field, bool no_conversions);
# 818 "./drizzled/field.h"
bool test_if_important_data(const charset_info_st * const cs,
                            const char *str,
                            const char *strend);

}
# 23 "./drizzled/order.h" 2

namespace drizzled {


class Order{
public:
  struct Order *next;
  Item **item;
  Item *item_ptr;
  Item **item_copy;
  int counter;

  bool asc;
  bool free_me;
  bool in_field_list;
  bool counter_used;
  Field *field;
  char *buff;
  table_map used, depend_map;

  Order():
    next(__null),
    item(__null),
    item_ptr(__null),
    item_copy(__null),
    counter(0),
    asc(false),
    free_me(false),
    in_field_list(false),
    counter_used(false),
    field(__null),
    buff(__null),
    used(0),
    depend_map(0)
  {}
};
}
# 27 "./drizzled/table.h" 2
# 1 "./drizzled/filesort_info.h" 1
# 20 "./drizzled/filesort_info.h"
# 1 "./drizzled/sql_sort.h" 1
# 20 "./drizzled/sql_sort.h"
       






namespace drizzled {
# 45 "./drizzled/sql_sort.h"
class sort_addon_field {
public:
  Field *field;
  uint32_t offset;
  uint32_t null_offset;
  uint32_t length;
  uint8_t null_bit;

  sort_addon_field() :
    field(__null),
    offset(0),
    null_offset(0),
    length(0),
    null_bit(0)
  { }

};

class buffpek {
public:
  off_t file_pos;
  unsigned char *base;
  unsigned char *key;
  ha_rows count;
  size_t mem_count;
  size_t max_keys;

  buffpek() :
    file_pos(0),
    base(0),
    key(0),
    count(0),
    mem_count(0),
    max_keys(0)
  { }

};

}
# 21 "./drizzled/filesort_info.h" 2
       


namespace drizzled
{


class filesort_info
{
public:
  internal::io_cache_st *io_cache;
  unsigned char **sort_keys;
  unsigned char *buffpek;
  uint32_t buffpek_len;
  unsigned char *addon_buf;
  size_t addon_length;
  sort_addon_field *addon_field;
  void (*unpack)(sort_addon_field *, unsigned char *);
  unsigned char *record_pointers;
  ha_rows found_records;

  filesort_info() :
    io_cache(0),
    sort_keys(0),
    buffpek(0),
    buffpek_len(0),
    addon_buf(0),
    addon_length(0),
    addon_field(0),
    unpack(0),
    record_pointers(0),
    found_records()
  { }

  filesort_info(const filesort_info& arg) :
    io_cache(arg.io_cache),
    sort_keys(arg.sort_keys),
    buffpek(arg.buffpek),
    buffpek_len(arg.buffpek_len),
    addon_buf(arg.addon_buf),
    addon_length(arg.addon_length),
    addon_field(arg.addon_field),
    unpack(arg.unpack),
    record_pointers(arg.record_pointers),
    found_records(arg.found_records)
  {
  }

  ~filesort_info()
  {
  }

};

}
# 28 "./drizzled/table.h" 2
# 1 "./drizzled/natural_join_column.h" 1
# 20 "./drizzled/natural_join_column.h"
       



namespace drizzled {







class Natural_join_column: public memory::SqlAlloc
{
public:
  Field *table_field;
  TableList *table_ref;







  bool is_common;
public:
  Natural_join_column(Field *field_param, TableList *tab);
  const char *name();
  Item *create_item(Session *session);
  Field *field();
  const char *table_name();
  const char *db_name();
};

}
# 29 "./drizzled/table.h" 2
# 1 "./drizzled/field_iterator.h" 1
# 21 "./drizzled/field_iterator.h"
       






namespace drizzled {





class Field_iterator : public memory::SqlAlloc
{
public:
  virtual ~Field_iterator() {}
  virtual void set(TableList *)= 0;
  virtual void next()= 0;
  virtual bool end_of_fields() const= 0;
  virtual const char *name() const= 0;
  virtual Item *create_item(Session *)= 0;
  virtual Field *field()= 0;
};







class Field_iterator_table : public Field_iterator
{
  Field **ptr;
public:
  Field_iterator_table() :ptr(0) {}
  void set(TableList *table);
  void set_table(Table *table);
  void next() { ptr++; }
  bool end_of_fields() const { return *ptr == 0; }
  const char *name() const;
  Item *create_item(Session *session);
  Field *field() { return *ptr; }
};
# 74 "./drizzled/field_iterator.h"
class Field_iterator_natural_join: public Field_iterator
{
  List<Natural_join_column>::iterator column_ref_it;
  Natural_join_column *cur_column_ref;
public:
  Field_iterator_natural_join() : cur_column_ref(__null) {}
  void set(TableList *table);
  void next();
  bool end_of_fields() const { return not cur_column_ref; }
  const char *name() const { return cur_column_ref->name(); }
  Item *create_item(Session *session) { return cur_column_ref->create_item(session); }
  Field *field() { return cur_column_ref->field(); }
  Natural_join_column *column_ref() { return cur_column_ref; }
};
# 106 "./drizzled/field_iterator.h"
class Field_iterator_table_ref: public Field_iterator
{
  TableList *table_ref, *first_leaf, *last_leaf;
  Field_iterator_table table_field_it;
  Field_iterator_natural_join natural_join_it;
  Field_iterator *field_it;
  void set_field_iterator();
public:
  Field_iterator_table_ref() :field_it(__null) {}
  void set(TableList *table);
  void next();
  bool end_of_fields() const
  { return (table_ref == last_leaf && field_it->end_of_fields()); }
  const char *name() const { return field_it->name(); }
  const char *table_name();
  const char *db_name();
  Item *create_item(Session *session) { return field_it->create_item(session); }
  Field *field() { return field_it->field(); }
  Natural_join_column *get_or_create_column_ref(TableList *parent_table_ref);
  Natural_join_column *get_natural_column_ref();
};

}
# 30 "./drizzled/table.h" 2
# 1 "./drizzled/cursor.h" 1
# 20 "./drizzled/cursor.h"
       

# 1 "./drizzled/atomics.h" 1
# 21 "./drizzled/atomics.h"
       





# 1 "./drizzled/atomic/gcc_traits.h" 1
# 20 "./drizzled/atomic/gcc_traits.h"
       

namespace drizzled {
namespace internal {

template<typename T, typename D>
class gcc_traits
{

public:
  typedef T value_type;

  gcc_traits() {}

  inline value_type add_and_fetch(volatile value_type *value, D addend )
  {
    return __sync_add_and_fetch(value, addend);
  }

  inline value_type fetch_and_add(volatile value_type *value, D addend )
  {
    return __sync_fetch_and_add(value, addend);
  }

  inline value_type fetch_and_increment(volatile value_type *value)
  {
    return __sync_fetch_and_add(value, 1);
  }

  inline value_type fetch_and_decrement(volatile value_type *value)
  {
    return __sync_fetch_and_sub(value, 1);
  }

  inline value_type fetch_and_store(volatile value_type *value,
                                    value_type new_value)
  {
    return __sync_lock_test_and_set(value, new_value);
  }

  inline bool compare_and_swap(volatile value_type *value,
                                     value_type new_value,
                                     value_type comparand )
  {
    return __sync_bool_compare_and_swap(value, comparand, new_value);
  }

  inline value_type fetch(const volatile value_type *value) const volatile
  {
# 79 "./drizzled/atomic/gcc_traits.h"
    return __sync_fetch_and_add(const_cast<value_type *>(value), 0);
  }

  inline value_type store_with_release(volatile value_type *value,
                                       value_type new_value)
  {
    *value= new_value;
    return *value;
  }

};


}
}
# 28 "./drizzled/atomics.h" 2







# 1 "./drizzled/atomic/pthread_traits.h" 1
# 21 "./drizzled/atomic/pthread_traits.h"
       

namespace drizzled {

namespace internal {

class mutex_wrapper
{
private:
  pthread_mutex_t the_mutex;
  bool locked;
public:
  mutex_wrapper(void)
   : the_mutex(),
     locked(false)
  {
    (void) pthread_mutex_init(&the_mutex, __null);
  }
  ~mutex_wrapper(void)
  {
    if (locked)
      unlock();
    pthread_mutex_destroy(&the_mutex);
  }
  void lock(void)
  {
    pthread_mutex_lock(&the_mutex);
    locked=true;
  }
  void unlock(void)
  {
    pthread_mutex_unlock(&the_mutex);
    locked=false;
  }
};

template<typename T, typename D>
class pthread_traits
{
private:
  mutex_wrapper my_lock;

public:

  typedef T value_type;

  pthread_traits() {}

  inline value_type add_and_fetch(volatile value_type *value, D addend )
  {
    my_lock.lock();
    *value += addend;
    value_type ret= *value;
    my_lock.unlock();
    return ret;
  }

  inline value_type fetch_and_add(volatile value_type *value, D addend )
  {
    my_lock.lock();
    value_type ret= *value;
    *value += addend;
    my_lock.unlock();
    return ret;
  }

  inline value_type fetch_and_increment(volatile value_type *value)
  {
    my_lock.lock();
    value_type ret= *value;
    (*value)++;
    my_lock.unlock();
    return ret;
  }

  inline value_type fetch_and_decrement(volatile value_type *value)
  {
    my_lock.lock();
    value_type ret= *value;
    (*value)--;
    my_lock.unlock();
    return ret;
  }

  inline value_type fetch_and_store(volatile value_type *value,
                                    value_type new_value )
  {
    my_lock.lock();
    value_type ret= *value;
    *value= new_value;
    my_lock.unlock();
    return ret;
  }

  inline bool compare_and_swap(volatile value_type *value,
                                     value_type new_value,
                                     value_type comparand )
  {
    my_lock.lock();
    bool ret= (*value == comparand);
    if (ret)
      *value= new_value;
    my_lock.unlock();
    return ret;
  }

  inline value_type fetch(const volatile value_type *value) const volatile
  {
    const_cast<pthread_traits *>(this)->my_lock.lock();
    value_type ret= *value;
    const_cast<pthread_traits *>(this)->my_lock.unlock();
    return ret;
  }

  inline value_type store_with_release(volatile value_type *value,
                                       value_type new_value)
  {
    my_lock.lock();
    *value= new_value;
    value_type ret= *value;
    my_lock.unlock();
    return ret;
  }

};


}
}
# 36 "./drizzled/atomics.h" 2


namespace drizzled {
namespace internal {

template<typename I>
struct atomic_base {
  volatile I my_value;
  atomic_base() : my_value(0) {}
  virtual ~atomic_base() {}
};

template<typename I, typename D, typename T >
class atomic_impl: private atomic_base<I>
{
  T traits;
public:
  typedef I value_type;

  atomic_impl() : atomic_base<I>(), traits() {}

  value_type add_and_fetch( D addend )
  {
    return traits.add_and_fetch(&this->my_value, addend);
  }

  value_type fetch_and_add( D addend )
  {
    return traits.fetch_and_add(&this->my_value, addend);
  }

  value_type fetch_and_increment()
  {
    return traits.fetch_and_increment(&this->my_value);
  }

  value_type fetch_and_decrement()
  {
    return traits.fetch_and_decrement(&this->my_value);
  }

  value_type fetch_and_store( value_type value )
  {
    return traits.fetch_and_store(&this->my_value, value);
  }

  bool compare_and_swap( value_type value, value_type comparand )
  {
    return traits.compare_and_swap(&this->my_value, value, comparand);
  }

  operator value_type() const volatile
  {
    return traits.fetch(&this->my_value);
  }

  value_type& _internal_reference() const
  {
    return this->my_value;
  }

protected:
  value_type store_with_release( value_type rhs )
  {
    return traits.store_with_release(&this->my_value, rhs);
  }

public:
  atomic_impl<I,D,T>& operator+=( D addend )
  {
    increment(addend);
    return *this;
  }

  atomic_impl<I,D,T>& operator-=( D addend )
  {


    return operator+=(D(0)-addend);
  }

  value_type increment()
  {
    return add_and_fetch(1);
  }

  value_type decrement()
  {
    return add_and_fetch(D(-1));
  }
};

}




template<typename T>
struct atomic {
};
# 147 "./drizzled/atomics.h"
template<> struct atomic<long> : internal::atomic_impl<long,long,internal::gcc_traits<long,long> > { atomic<long>() : internal::atomic_impl<long,long,internal::gcc_traits<long,long> >() {} atomic<long>& operator=( long rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<unsigned long> : internal::atomic_impl<unsigned long,unsigned long,internal::gcc_traits<unsigned long,unsigned long> > { atomic<unsigned long>() : internal::atomic_impl<unsigned long,unsigned long,internal::gcc_traits<unsigned long,unsigned long> >() {} atomic<unsigned long>& operator=( unsigned long rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<unsigned int> : internal::atomic_impl<unsigned int,unsigned int,internal::gcc_traits<unsigned int,unsigned int> > { atomic<unsigned int>() : internal::atomic_impl<unsigned int,unsigned int,internal::gcc_traits<unsigned int,unsigned int> >() {} atomic<unsigned int>& operator=( unsigned int rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<int> : internal::atomic_impl<int,int,internal::gcc_traits<int,int> > { atomic<int>() : internal::atomic_impl<int,int,internal::gcc_traits<int,int> >() {} atomic<int>& operator=( int rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<unsigned short> : internal::atomic_impl<unsigned short,unsigned short,internal::gcc_traits<unsigned short,unsigned short> > { atomic<unsigned short>() : internal::atomic_impl<unsigned short,unsigned short,internal::gcc_traits<unsigned short,unsigned short> >() {} atomic<unsigned short>& operator=( unsigned short rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<short> : internal::atomic_impl<short,short,internal::gcc_traits<short,short> > { atomic<short>() : internal::atomic_impl<short,short,internal::gcc_traits<short,short> >() {} atomic<short>& operator=( short rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<char> : internal::atomic_impl<char,char,internal::gcc_traits<char,char> > { atomic<char>() : internal::atomic_impl<char,char,internal::gcc_traits<char,char> >() {} atomic<char>& operator=( char rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<signed char> : internal::atomic_impl<signed char,signed char,internal::gcc_traits<signed char,signed char> > { atomic<signed char>() : internal::atomic_impl<signed char,signed char,internal::gcc_traits<signed char,signed char> >() {} atomic<signed char>& operator=( signed char rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<unsigned char> : internal::atomic_impl<unsigned char,unsigned char,internal::gcc_traits<unsigned char,unsigned char> > { atomic<unsigned char>() : internal::atomic_impl<unsigned char,unsigned char,internal::gcc_traits<unsigned char,unsigned char> >() {} atomic<unsigned char>& operator=( unsigned char rhs ) { store_with_release(rhs); return *this; } };
template<> struct atomic<bool> : internal::atomic_impl<bool,bool,internal::gcc_traits<bool,bool> > { atomic<bool>() : internal::atomic_impl<bool,bool,internal::gcc_traits<bool,bool> >() {} atomic<bool>& operator=( bool rhs ) { store_with_release(rhs); return *this; } };
# 173 "./drizzled/atomics.h"
template<> struct atomic<long long> : internal::atomic_impl<long long,long long,internal::pthread_traits<long long,long long> > { atomic<long long>() : internal::atomic_impl<long long,long long,internal::pthread_traits<long long,long long> >() {} long long operator=( long long rhs ) { return store_with_release(rhs); } };
template<> struct atomic<unsigned long long> : internal::atomic_impl<unsigned long long,unsigned long long,internal::pthread_traits<unsigned long long,unsigned long long> > { atomic<unsigned long long>() : internal::atomic_impl<unsigned long long,unsigned long long,internal::pthread_traits<unsigned long long,unsigned long long> >() {} unsigned long long operator=( unsigned long long rhs ) { return store_with_release(rhs); } };



}
# 23 "./drizzled/cursor.h" 2

# 1 "./drizzled/discrete_interval.h" 1
# 21 "./drizzled/discrete_interval.h"
       

# 1 "/usr/include/c++/4.8/cstdlib" 1 3
# 39 "/usr/include/c++/4.8/cstdlib" 3
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 24 "./drizzled/discrete_interval.h" 2



namespace drizzled
{
# 39 "./drizzled/discrete_interval.h"
class Discrete_interval {
private:
  uint64_t interval_min;
  uint64_t interval_values;
  uint64_t interval_max;
public:
  Discrete_interval *next;
  void replace(uint64_t start, uint64_t val, uint64_t incr)
  {
    interval_min= start;
    interval_values= val;
    interval_max= (val == (18446744073709551615ULL)) ? val : start + val * incr;
  }
  Discrete_interval(uint64_t start, uint64_t val, uint64_t incr) :
    interval_min(start), interval_values(val),
    interval_max((val == (18446744073709551615ULL)) ? val : start + val * incr),
    next(__null)
  {}
  Discrete_interval() :
    interval_min(0), interval_values(0),
    interval_max(0), next(__null)
  {}
  uint64_t minimum() const { return interval_min; }
  uint64_t values() const { return interval_values; }
  uint64_t maximum() const { return interval_max; }





  bool merge_if_contiguous(uint64_t start, uint64_t val, uint64_t incr)
  {
    if (interval_max == start)
    {
      if (val == (18446744073709551615ULL))
      {
        interval_values= interval_max= val;
      }
      else
      {
        interval_values+= val;
        interval_max= start + val * incr;
      }
      return 0;
    }
    return 1;
  }
};




class Discrete_intervals_list {
private:
  Discrete_interval *head;
  Discrete_interval *tail;






  Discrete_interval *current;
  uint32_t elements;


  void copy_(const Discrete_intervals_list& from)
  {
    for (Discrete_interval *i= from.head; i; i= i->next)
    {
      Discrete_interval j= *i;
      append(&j);
    }
  }
public:
  Discrete_intervals_list() :
    head(__null), tail(__null),
    current(__null), elements(0) {}
  Discrete_intervals_list(const Discrete_intervals_list& from) :
    head(__null), tail(__null),
    current(__null), elements(0)
  {
    copy_(from);
  }
  Discrete_intervals_list& operator=(const Discrete_intervals_list& from)
  {
    empty();
    copy_(from);
    return *this;
  }
  void empty_no_free()
  {
    head= current= __null;
    elements= 0;
  }
  void empty()
  {
    for (Discrete_interval *i= head; i;)
    {
      Discrete_interval *next= i->next;
      delete i;
      i= next;
    }
    empty_no_free();
  }

  const Discrete_interval* get_next()
  {
    Discrete_interval *tmp= current;
    if (current != __null)
      current= current->next;
    return tmp;
  }
  ~Discrete_intervals_list() { empty(); }
  uint64_t minimum() const { return (head ? head->minimum() : 0); }
  uint64_t maximum() const { return (head ? tail->maximum() : 0); }
  uint32_t nb_elements() const { return elements; }

  bool append(uint64_t start, uint64_t val, uint64_t incr)
  {

    if ((head == __null) || tail->merge_if_contiguous(start, val, incr))
    {

      Discrete_interval *new_interval= new Discrete_interval(start, val, incr);
      return(append(new_interval));
    }
    return 0;
  }

  bool append(Discrete_interval *new_interval)
  {
    if (__builtin_expect((new_interval == __null),0))
      return 1;
    if (head == __null)
      head= current= new_interval;
    else
      tail->next= new_interval;
    tail= new_interval;
    elements++;
    return 0;
  }

};

}
# 25 "./drizzled/cursor.h" 2

# 1 "./drizzled/ha_statistics.h" 1
# 20 "./drizzled/ha_statistics.h"
       




namespace drizzled
{

class ha_statistics
{
public:
  uint64_t data_file_length;
  uint64_t max_data_file_length;
  uint64_t index_file_length;
  uint64_t max_index_file_length;
  uint64_t delete_length;
  uint64_t auto_increment_value;
# 45 "./drizzled/ha_statistics.h"
  ha_rows records;
  ha_rows deleted;
  uint32_t mean_rec_length;
  uint32_t block_size;
  time_t create_time;
  time_t check_time;
  time_t update_time;

  ha_statistics():
    data_file_length(0), max_data_file_length(0),
    index_file_length(0), delete_length(0), auto_increment_value(0),
    records(0), deleted(0), mean_rec_length(0), block_size(0),
    create_time(0), check_time(0), update_time(0)
  {}
};

}
# 27 "./drizzled/cursor.h" 2
# 1 "./drizzled/handler_structs.h" 1
# 20 "./drizzled/handler_structs.h"
       
# 38 "./drizzled/handler_structs.h"
namespace drizzled {

typedef struct st_ha_create_information
{
  const charset_info_st *table_charset, *default_table_charset;
  const char *alias;
  uint64_t auto_increment_value;
  uint32_t table_options;
  uint32_t used_fields;
  plugin::StorageEngine *db_type;
  bool table_existed;

  st_ha_create_information() :
    table_charset(0),
    default_table_charset(0),
    alias(0),
    auto_increment_value(0),
    table_options(0),
    used_fields(0),
    db_type(0),
    table_existed(0)
  { }
} HA_CREATE_INFO;

typedef struct st_ha_alter_information
{
  KeyInfo *key_info_buffer;
  uint32_t key_count;
  uint32_t index_drop_count;
  uint32_t *index_drop_buffer;
  uint32_t index_add_count;
  uint32_t *index_add_buffer;
  void *data;

  st_ha_alter_information() :
    key_info_buffer(0),
    key_count(0),
    index_drop_count(0),
    index_drop_buffer(0),
    index_add_count(0),
    index_add_buffer(0),
    data(0)
  { }

} HA_ALTER_INFO;


struct KEY_CREATE_INFO
{
  KEY_CREATE_INFO() :
    algorithm(HA_KEY_ALG_UNDEF),
    block_size(0)
  {
  }

  ha_key_alg algorithm;
  uint32_t block_size;
  str_ref comment;
};


typedef struct st_range_seq_if
{
# 113 "./drizzled/handler_structs.h"
  range_seq_t (*init)(void *init_params, uint32_t n_ranges, uint32_t flags);
# 128 "./drizzled/handler_structs.h"
  uint32_t (*next) (range_seq_t seq, KEY_MULTI_RANGE *range);
} RANGE_SEQ_IF;

}
# 28 "./drizzled/cursor.h" 2


# 1 "./drizzled/message/table.h" 1
# 22 "./drizzled/message/table.h"
       

# 1 "/usr/include/uuid/uuid.h" 1 3 4
# 44 "/usr/include/uuid/uuid.h" 3 4
typedef unsigned char uuid_t[16];
# 66 "/usr/include/uuid/uuid.h" 3 4
extern "C" {



void uuid_clear(uuid_t uu);


int uuid_compare(const uuid_t uu1, const uuid_t uu2);


void uuid_copy(uuid_t dst, const uuid_t src);


void uuid_generate(uuid_t out);
void uuid_generate_random(uuid_t out);
void uuid_generate_time(uuid_t out);
int uuid_generate_time_safe(uuid_t out);


int uuid_is_null(const uuid_t uu);


int uuid_parse(const char *in, uuid_t uu);


void uuid_unparse(const uuid_t uu, char *out);
void uuid_unparse_lower(const uuid_t uu, char *out);
void uuid_unparse_upper(const uuid_t uu, char *out);


time_t uuid_time(const uuid_t uu, struct timeval *ret_tv);
int uuid_type(const uuid_t uu);
int uuid_variant(const uuid_t uu);


}
# 25 "./drizzled/message/table.h" 2





namespace drizzled {
namespace message {
namespace table {

typedef boost::shared_ptr <message::Table> shared_ptr;
typedef const message::Table& const_reference;

shared_ptr make_shared(const identifier::Table& identifier, const std::string &engine_arg);
shared_ptr make_shared(const std::string &name_arg, const std::string &schema_arg, const std::string &engine_arg);
void init(drizzled::message::Table &arg, const std::string &name_arg, const std::string &schema_arg, const std::string &engine_arg);
void update(drizzled::message::Table &arg);

}
}
}
# 31 "./drizzled/cursor.h" 2
# 39 "./drizzled/cursor.h"
namespace drizzled {



typedef std::bitset<40> HA_ALTER_FLAGS;

typedef List<Item> List_item;
extern KEY_CREATE_INFO default_key_create_info;





inline key_part_map make_keypart_map(int a)
{
  return (((key_part_map)2 << a) - 1);
}





inline key_part_map make_prev_keypart_map(int a)
{
  return (((key_part_map)1 << a) - 1);
}
# 109 "./drizzled/cursor.h"
class __attribute__ ((visibility("default"))) Cursor
{
  friend class SEAPITesterCursor;
  Table &table;
  plugin::StorageEngine &engine;

protected:
  ha_rows estimation_rows_to_insert;

public:
  inline plugin::StorageEngine *getEngine() const
  {
    return &engine;
  }
  unsigned char *ref;
  unsigned char *dup_ref;

  TableShare *getShare();

  Table *getTable() const
  {
    return &table;
  }

  ha_statistics stats;

  range_seq_t mrr_iter;
  RANGE_SEQ_IF mrr_funcs;

  uint32_t ranges_in_seq;

  bool mrr_is_output_sorted;


  bool mrr_have_range;

  bool eq_range;


  KEY_MULTI_RANGE mrr_cur_range;


  key_range save_end_range, *end_range;
  KeyPartInfo *range_key_part;
  int key_compare_result_on_equal;

  uint32_t errkey;
  uint32_t key_used_on_scan;
  uint32_t active_index;

  uint32_t ref_length;
  enum {NONE=0, INDEX, RND} inited;
  bool locked;
# 172 "./drizzled/cursor.h"
  uint64_t next_insert_id;
  uint64_t getNextInsertId() const
  {
    return next_insert_id;
  }




  uint64_t getAutoIncrement() const
  {
    return stats.auto_increment_value;
  }







  uint64_t insert_id_for_cur_row;




  Discrete_interval auto_inc_interval_for_cur_row;

  Cursor(plugin::StorageEngine &engine_arg, Table &share_arg);
  virtual ~Cursor(void);
  virtual Cursor *clone(memory::Root *mem_root);



  int ha_open(const identifier::Table &identifier, int mode, int test_if_locked);
  int startIndexScan(uint32_t idx, bool sorted) __attribute__ ((warn_unused_result));
  int endIndexScan();
  int startTableScan(bool scan) __attribute__ ((warn_unused_result));
  int endTableScan();
  int ha_reset();


  int ha_index_or_rnd_end();







  int ha_external_lock(Session *session, int lock_type);
  int insertRecord(unsigned char * buf) __attribute__ ((warn_unused_result));
  int updateRecord(const unsigned char * old_data, unsigned char * new_data) __attribute__ ((warn_unused_result));
  int deleteRecord(const unsigned char * buf) __attribute__ ((warn_unused_result));
  void ha_release_auto_increment();
  int ha_check(Session*);
  void ha_start_bulk_insert(ha_rows rows);
  int ha_end_bulk_insert();
  int ha_delete_all_rows();
  int ha_reset_auto_increment(uint64_t value);
  int ha_analyze(Session*);

  int ha_disable_indexes(uint32_t mode);
  int ha_enable_indexes(uint32_t mode);
  int ha_discard_or_import_tablespace(bool discard);
  void closeMarkForDelete();

  void adjust_next_insert_id_after_explicit_value(uint64_t nr);
  int update_auto_increment();


  virtual double scan_time(void)
  { return static_cast<double>(stats.data_file_length) / 4096 + 2; }
  virtual double read_time(uint32_t, uint32_t ranges, ha_rows rows)
  { return ranges + rows; }

  virtual double index_only_read_time(uint32_t keynr, double records);

  virtual ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
                                              void *seq_init_param,
                                              uint32_t n_ranges, uint32_t *bufsz,
                                              uint32_t *flags, optimizer::CostVector *cost);
  virtual int multi_range_read_info(uint32_t keyno, uint32_t n_ranges, uint32_t keys,
                                    uint32_t *bufsz, uint32_t *flags, optimizer::CostVector *cost);
  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
                                    uint32_t n_ranges, uint32_t mode);
  virtual int multi_range_read_next(char **range_info);


  virtual const key_map *keys_to_use_for_scanning();
  bool has_transactions();
# 273 "./drizzled/cursor.h"
  virtual bool is_fatal_error(int error, uint32_t flags);





  virtual ha_rows records();
  virtual uint64_t tableSize();
  virtual uint64_t rowSize();






  virtual ha_rows estimate_rows_upper_bound()
  { return stats.records+10; }

  virtual const char *index_type(uint32_t)
  { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/cursor.h", 292, __PRETTY_FUNCTION__)); return "";}


  uint32_t get_index(void) const { return active_index; }
  virtual int close(void)=0;







  virtual int index_read_map(unsigned char * buf, const unsigned char *key,
                             key_part_map keypart_map,
                             enum ha_rkey_function find_flag)
  {
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
    return index_read(buf, key, key_len, find_flag);
  }






  virtual int index_read_idx_map(unsigned char * buf, uint32_t index,
                                 const unsigned char * key,
                                 key_part_map keypart_map,
                                 enum ha_rkey_function find_flag);
  virtual int index_next(unsigned char *) __attribute__ ((warn_unused_result))
   { return HA_ERR_WRONG_COMMAND; }
  virtual int index_prev(unsigned char *)
   { return HA_ERR_WRONG_COMMAND; }
  virtual int index_first(unsigned char *)
   { return HA_ERR_WRONG_COMMAND; }
  virtual int index_last(unsigned char *)
   { return HA_ERR_WRONG_COMMAND; }
  virtual int index_next_same(unsigned char *, const unsigned char *, uint32_t);

private:
  uint32_t calculate_key_len(uint32_t key_position, key_part_map keypart_map_arg);
public:






  virtual int index_read_last_map(unsigned char * buf, const unsigned char * key,
                                  key_part_map keypart_map)
  {
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
    return index_read_last(buf, key, key_len);
  }
  virtual int read_range_first(const key_range *start_key,
                               const key_range *end_key,
                               bool eq_range, bool sorted);
  virtual int read_range_next();
  int compare_key(key_range *range);
  virtual int rnd_next(unsigned char *)=0;
  virtual int rnd_pos(unsigned char *, unsigned char *)=0;
  virtual int read_first_row(unsigned char *buf, uint32_t primary_key);
  virtual int rnd_same(unsigned char *, uint32_t)
    { return HA_ERR_WRONG_COMMAND; }
  virtual ha_rows records_in_range(uint32_t, key_range *, key_range *)
    { return (ha_rows) 10; }
  virtual void position(const unsigned char *record)=0;
  virtual int info(uint32_t)=0;
  virtual uint32_t calculate_key_hash_value(Field **)
  { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/cursor.h", 361, __PRETTY_FUNCTION__)); return 0; }
  virtual int extra(enum ha_extra_function)
  { return 0; }
  virtual int extra_opt(enum ha_extra_function operation, uint32_t)
  { return extra(operation); }
# 379 "./drizzled/cursor.h"
  virtual bool was_semi_consistent_read() { return 0; }






  virtual void try_semi_consistent_read(bool) {}
  virtual void unlock_row(void) {}
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
                                  uint64_t nb_desired_values,
                                  uint64_t *first_value,
                                  uint64_t *nb_reserved_values)= 0;

  void set_next_insert_id(uint64_t id)
  {
    next_insert_id= id;
  }
  void restore_auto_increment(uint64_t prev_insert_id)
  {
# 409 "./drizzled/cursor.h"
    next_insert_id= (prev_insert_id > 0) ? prev_insert_id :
      insert_id_for_cur_row;
  }



  virtual int indexes_are_disabled(void) {return 0;}
  virtual void append_create_info(String *)
  {}
# 428 "./drizzled/cursor.h"
  virtual char* get_foreign_key_create_info(void)
  { return __null;}



  virtual bool can_switch_engines(void) { return true; }

  virtual int get_foreign_key_list(Session *, List<ForeignKeyInfo> *)
  { return 0; }
  virtual uint32_t referenced_by_foreign_key() { return 0;}
  virtual void free_foreign_key_create_info(char *) {}
# 453 "./drizzled/cursor.h"
  virtual THR_LOCK_DATA **store_lock(Session *,
                                     THR_LOCK_DATA **to,
                                     enum thr_lock_type)
  {
    ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/cursor.h", 457, __PRETTY_FUNCTION__));

    return(to);
  }






 virtual bool primary_key_is_clustered() { return false; }
 virtual int cmp_ref(const unsigned char *ref1, const unsigned char *ref2)
 {
   return memcmp(ref1, ref2, ref_length);
 }

  virtual bool isOrdered(void)
  {
    return false;
  }


protected:

  void ha_statistic_increment(uint64_t system_status_var::*offset) const;
  void **ha_data(Session *) const;

private:

  inline void setTransactionReadWrite();
private:






  virtual int open(const char *, int , uint32_t ) { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/cursor.h", 494, __PRETTY_FUNCTION__)); return -1; }
  virtual int doOpen(const identifier::Table &identifier, int mode, uint32_t test_if_locked);
  virtual int doStartIndexScan(uint32_t idx, bool)
  { active_index= idx; return 0; }
  virtual int doEndIndexScan() { active_index= MAX_KEY; return 0; }







  virtual int doStartTableScan(bool scan) __attribute__ ((warn_unused_result)) = 0;
  virtual int doEndTableScan() { return 0; }
  virtual int doInsertRecord(unsigned char *)
  {
    return HA_ERR_WRONG_COMMAND;
  }

  virtual int doUpdateRecord(const unsigned char *, unsigned char *)
  {
    return HA_ERR_WRONG_COMMAND;
  }

  virtual int doDeleteRecord(const unsigned char *)
  {
    return HA_ERR_WRONG_COMMAND;
  }





  virtual int reset() { return 0; }
# 551 "./drizzled/cursor.h"
  virtual int external_lock(Session *, int)
  {
    return 0;
  }
  virtual void release_auto_increment(void) { return; }

  virtual int check(Session *)
  { return -1; }

  virtual void start_bulk_insert(ha_rows)
  {}
  virtual int end_bulk_insert(void) { return 0; }
  virtual int index_read(unsigned char *, const unsigned char *,
                         uint32_t, enum ha_rkey_function)
   { return HA_ERR_WRONG_COMMAND; }
  virtual int index_read_last(unsigned char *, const unsigned char *, uint32_t)
   { return ((*__errno_location ())= HA_ERR_WRONG_COMMAND); }






  virtual int delete_all_rows(void)
  { return ((*__errno_location ())=HA_ERR_WRONG_COMMAND); }






  virtual int reset_auto_increment(uint64_t)
  { return HA_ERR_WRONG_COMMAND; }

  virtual int analyze(Session *)
  { return -1; }

  virtual int disable_indexes(uint32_t)
  { return HA_ERR_WRONG_COMMAND; }

  virtual int enable_indexes(uint32_t)
  { return HA_ERR_WRONG_COMMAND; }

  virtual int discard_or_import_tablespace(bool)
  { return ((*__errno_location ())=HA_ERR_WRONG_COMMAND); }







  virtual void drop_table();
};

extern const char *ha_row_type[];


void ha_init_errors(void);

SortField *make_unireg_sortorder(Order *order, uint32_t *length,
                                 SortField *sortorder);
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables,
                List<Item> &fields, List <Item> &all_fields, Order *order);
int setup_group(Session *session, Item **ref_pointer_array, TableList *tables,
                List<Item> &fields, List<Item> &all_fields, Order *order,
                bool *hidden_group_fields);
bool fix_inner_refs(Session *session, List<Item> &all_fields, Select_Lex *select,
                    Item **ref_pointer_array);

bool handle_select(Session *session, LEX *lex, select_result *result,
                   uint64_t setup_tables_done_option);
void free_underlaid_joins(Session *session, Select_Lex *select);

bool handle_derived(LEX *lex, bool (*processor)(Session *session,
                                                      LEX *lex,
                                                      TableList *table));
bool derived_prepare(Session *session, LEX *lex, TableList *t);
bool derived_filling(Session *session, LEX *lex, TableList *t);
int prepare_create_field(CreateField *sql_field,
                         uint32_t *blob_columns,
                         int *timestamps, int *timestamps_with_niladic);

bool create_table(Session *session,
                  const identifier::Table &identifier,
                  HA_CREATE_INFO *create_info,
                  message::Table &table_proto,
                  AlterInfo *alter_info,
                  bool tmp_table, uint32_t select_field_count,
                  bool is_if_not_exists);

bool create_table_no_lock(Session *session,
                          const identifier::Table &identifier,
                          HA_CREATE_INFO *create_info,
                          message::Table &table_proto,
                          AlterInfo *alter_info,
                          bool tmp_table, uint32_t select_field_count,
                          bool is_if_not_exists);

bool create_like_table(Session* session,
                       const identifier::Table& destination_identifier,
                       const identifier::Table& source_identifier,
                       message::Table &create_table_proto,
                       bool is_if_not_exists,
                       bool is_engine_set);

bool rename_table(Session &session,
                        plugin::StorageEngine *base,
                        const identifier::Table &old_identifier,
                        const identifier::Table &new_identifier);

bool prepare_update(Session *session, TableList *table_list,
                          Item **conds, uint32_t order_num, Order *order);
int update_query(Session *session,TableList *tables,List<Item> &fields,
                 List<Item> &values,COND *conds,
                 uint32_t order_num, Order *order, ha_rows limit,
                 enum enum_duplicates handle_duplicates, bool ignore);
bool prepare_insert(Session *session, TableList *table_list, Table *table,
                          List<Item> &fields, List_item *values,
                          List<Item> &update_fields,
                          List<Item> &update_values, enum_duplicates duplic,
                          COND **where, bool select_insert,
                          bool check_fields, bool abort_on_warning);
bool insert_query(Session *session,TableList *table,List<Item> &fields,
                  List<List_item> &values, List<Item> &update_fields,
                  List<Item> &update_values, enum_duplicates flag,
                  bool ignore);
int check_that_all_fields_are_given_values(Session *session, Table *entry,
                                           TableList *table_list);
int prepare_delete(Session *session, TableList *table_list, Item **conds);
bool delete_query(Session *session, TableList *table_list, COND *conds,
                  SQL_LIST *order, ha_rows rows, uint64_t options,
                  bool reset_auto_increment);
bool truncate(Session& session, TableList *table_list);
TableShare *get_table_share(Session *session, TableList *table_list, char *key,
                             uint32_t key_length, uint32_t db_flags, int *error);
TableShare *get_cached_table_share(const char *db, const char *table_name);
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in);
bool reopen_tables(Session *session,bool get_locks,bool in_refresh);
void close_handle_and_leave_table_as_lock(Table *table);
bool wait_for_tables(Session *session);
bool table_is_used(Table *table, bool wait_for_name_lock);
Table *drop_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
void abort_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
extern Field *not_found_field;
extern Field *view_ref_found;

Field *
find_field_in_tables(Session *session, Item_ident *item,
                     TableList *first_table, TableList *last_table,
                     Item **ref, find_item_error_report_type report_error,
                     bool register_tree_change);
Field *
find_field_in_table_ref(Session *session, TableList *table_list,
                        const char *name, uint32_t length,
                        const char *item_name, const char *db_name,
                        const char *table_name, Item **ref,
                        bool allow_rowid,
                        uint32_t *cached_field_index_ptr,
                        bool register_tree_change, TableList **actual_table);
Field *
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
                    bool allow_rowid, uint32_t *cached_field_index_ptr);

}
# 31 "./drizzled/table.h" 2

# 1 "./drizzled/table/instance.h" 1
# 22 "./drizzled/table/instance.h"
       

# 1 "./drizzled/table/instance/base.h" 1
# 26 "./drizzled/table/instance/base.h"
       
# 37 "./drizzled/table/instance/base.h"
# 1 "./drizzled/message.h" 1
# 21 "./drizzled/message.h"
       

# 1 "./drizzled/message/access.h" 1
# 21 "./drizzled/message/access.h"
       


# 1 "./drizzled/message/access.pb.h" 1
# 25 "./drizzled/message/access.h" 2

namespace drizzled {
namespace message {

template<class T> void set_definer(T& reference, const identifier::User &arg)
{
  message::Access *access= reference.mutable_access();
  access->set_definer(arg.username());
}

template<class T> bool has_definer(const T& reference)
{
  if (reference.has_access() and reference.access().has_definer() and (not reference.access().definer().empty()))
  {
    return true;
  }

  return false;
}

template<class T> const char *definer(const T& reference)
{
  if (reference.has_access() and reference.access().has_definer())
  {
    return reference.access().definer().c_str();
  }

  return "";
}

}
}
# 24 "./drizzled/message.h" 2
# 1 "./drizzled/message/replication_options.h" 1
# 22 "./drizzled/message/replication_options.h"
       

# 1 "./drizzled/message/replication_options.pb.h" 1
# 25 "./drizzled/message/replication_options.h" 2

namespace drizzled {
namespace message {

template<class T> bool is_replicated(const T& reference)
{
  if (reference.has_replication_options() and
      reference.replication_options().has_is_replicated())
  {
    return reference.replication_options().is_replicated();
  }

  return true;
}

template<class T> void set_is_replicated(T& reference, bool arg)
{
  message::ReplicationOptions *options= reference.mutable_replication_options();
  options->set_is_replicated(arg);
}

}
}
# 25 "./drizzled/message.h" 2
# 1 "./drizzled/message/schema.h" 1
# 22 "./drizzled/message/schema.h"
       


# 1 "./drizzled/message/schema.pb.h" 1
# 31 "./drizzled/message/schema.pb.h"
namespace drizzled {
namespace message {


void protobuf_AddDesc_schema_2eproto();
void protobuf_AssignDesc_schema_2eproto();
void protobuf_ShutdownFile_schema_2eproto();

class Schema;
class Schema_Options;



class Schema_Options : public ::google::protobuf::Message {
 public:
  Schema_Options();
  virtual ~Schema_Options();

  Schema_Options(const Schema_Options& from);

  inline Schema_Options& operator=(const Schema_Options& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Schema_Options& default_instance();

  void Swap(Schema_Options* other);



  Schema_Options* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Schema_Options& from);
  void MergeFrom(const Schema_Options& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;






 private:

  ::google::protobuf::UnknownFieldSet _unknown_fields_;


  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[1];

  friend void protobuf_AddDesc_schema_2eproto();
  friend void protobuf_AssignDesc_schema_2eproto();
  friend void protobuf_ShutdownFile_schema_2eproto();

  void InitAsDefaultInstance();
  static Schema_Options* default_instance_;
};


class Schema : public ::google::protobuf::Message {
 public:
  Schema();
  virtual ~Schema();

  Schema(const Schema& from);

  inline Schema& operator=(const Schema& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }

  static const ::google::protobuf::Descriptor* descriptor();
  static const Schema& default_instance();

  void Swap(Schema* other);



  Schema* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Schema& from);
  void MergeFrom(const Schema& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:

  ::google::protobuf::Metadata GetMetadata() const;



  typedef Schema_Options Options;




  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();


  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 2;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  inline ::std::string* release_collation();


  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 3;
  inline const ::drizzled::message::Engine& engine() const;
  inline ::drizzled::message::Engine* mutable_engine();
  inline ::drizzled::message::Engine* release_engine();


  inline bool has_catalog() const;
  inline void clear_catalog();
  static const int kCatalogFieldNumber = 4;
  inline const ::std::string& catalog() const;
  inline void set_catalog(const ::std::string& value);
  inline void set_catalog(const char* value);
  inline void set_catalog(const char* value, size_t size);
  inline ::std::string* mutable_catalog();
  inline ::std::string* release_catalog();


  inline bool has_creation_timestamp() const;
  inline void clear_creation_timestamp();
  static const int kCreationTimestampFieldNumber = 11;
  inline ::google::protobuf::uint64 creation_timestamp() const;
  inline void set_creation_timestamp(::google::protobuf::uint64 value);


  inline bool has_update_timestamp() const;
  inline void clear_update_timestamp();
  static const int kUpdateTimestampFieldNumber = 12;
  inline ::google::protobuf::uint64 update_timestamp() const;
  inline void set_update_timestamp(::google::protobuf::uint64 value);


  inline bool has_uuid() const;
  inline void clear_uuid();
  static const int kUuidFieldNumber = 13;
  inline const ::std::string& uuid() const;
  inline void set_uuid(const ::std::string& value);
  inline void set_uuid(const char* value);
  inline void set_uuid(const char* value, size_t size);
  inline ::std::string* mutable_uuid();
  inline ::std::string* release_uuid();


  inline bool has_version() const;
  inline void clear_version();
  static const int kVersionFieldNumber = 14;
  inline ::google::protobuf::uint64 version() const;
  inline void set_version(::google::protobuf::uint64 value);


  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 15;
  inline const ::drizzled::message::Schema_Options& options() const;
  inline ::drizzled::message::Schema_Options* mutable_options();
  inline ::drizzled::message::Schema_Options* release_options();


  inline bool has_replication_options() const;
  inline void clear_replication_options();
  static const int kReplicationOptionsFieldNumber = 16;
  inline const ::drizzled::message::ReplicationOptions& replication_options() const;
  inline ::drizzled::message::ReplicationOptions* mutable_replication_options();
  inline ::drizzled::message::ReplicationOptions* release_replication_options();


  inline bool has_access() const;
  inline void clear_access();
  static const int kAccessFieldNumber = 17;
  inline const ::drizzled::message::Access& access() const;
  inline ::drizzled::message::Access* mutable_access();
  inline ::drizzled::message::Access* release_access();


 private:
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_collation();
  inline void clear_has_collation();
  inline void set_has_engine();
  inline void clear_has_engine();
  inline void set_has_catalog();
  inline void clear_has_catalog();
  inline void set_has_creation_timestamp();
  inline void clear_has_creation_timestamp();
  inline void set_has_update_timestamp();
  inline void clear_has_update_timestamp();
  inline void set_has_uuid();
  inline void clear_has_uuid();
  inline void set_has_version();
  inline void clear_has_version();
  inline void set_has_options();
  inline void clear_has_options();
  inline void set_has_replication_options();
  inline void clear_has_replication_options();
  inline void set_has_access();
  inline void clear_has_access();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::std::string* name_;
  ::std::string* collation_;
  ::drizzled::message::Engine* engine_;
  ::std::string* catalog_;
  ::google::protobuf::uint64 creation_timestamp_;
  ::google::protobuf::uint64 update_timestamp_;
  ::std::string* uuid_;
  ::google::protobuf::uint64 version_;
  ::drizzled::message::Schema_Options* options_;
  ::drizzled::message::ReplicationOptions* replication_options_;
  ::drizzled::message::Access* access_;

  mutable int _cached_size_;
  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];

  friend void protobuf_AddDesc_schema_2eproto();
  friend void protobuf_AssignDesc_schema_2eproto();
  friend void protobuf_ShutdownFile_schema_2eproto();

  void InitAsDefaultInstance();
  static Schema* default_instance_;
};
# 330 "./drizzled/message/schema.pb.h"
inline bool Schema::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Schema::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Schema::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Schema::clear_name() {
  if (name_ != &::google::protobuf::internal::kEmptyString) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& Schema::name() const {
  return *name_;
}
inline void Schema::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Schema::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Schema::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Schema::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    name_ = new ::std::string;
  }
  return name_;
}
inline ::std::string* Schema::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Schema::has_collation() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Schema::set_has_collation() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Schema::clear_has_collation() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Schema::clear_collation() {
  if (collation_ != &::google::protobuf::internal::kEmptyString) {
    collation_->clear();
  }
  clear_has_collation();
}
inline const ::std::string& Schema::collation() const {
  return *collation_;
}
inline void Schema::set_collation(const ::std::string& value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Schema::set_collation(const char* value) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Schema::set_collation(const char* value, size_t size) {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Schema::mutable_collation() {
  set_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    collation_ = new ::std::string;
  }
  return collation_;
}
inline ::std::string* Schema::release_collation() {
  clear_has_collation();
  if (collation_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = collation_;
    collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Schema::has_engine() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Schema::set_has_engine() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Schema::clear_has_engine() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Schema::clear_engine() {
  if (engine_ != __null) engine_->::drizzled::message::Engine::Clear();
  clear_has_engine();
}
inline const ::drizzled::message::Engine& Schema::engine() const {
  return engine_ != __null ? *engine_ : *default_instance_->engine_;
}
inline ::drizzled::message::Engine* Schema::mutable_engine() {
  set_has_engine();
  if (engine_ == __null) engine_ = new ::drizzled::message::Engine;
  return engine_;
}
inline ::drizzled::message::Engine* Schema::release_engine() {
  clear_has_engine();
  ::drizzled::message::Engine* temp = engine_;
  engine_ = __null;
  return temp;
}


inline bool Schema::has_catalog() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Schema::set_has_catalog() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Schema::clear_has_catalog() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Schema::clear_catalog() {
  if (catalog_ != &::google::protobuf::internal::kEmptyString) {
    catalog_->clear();
  }
  clear_has_catalog();
}
inline const ::std::string& Schema::catalog() const {
  return *catalog_;
}
inline void Schema::set_catalog(const ::std::string& value) {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(value);
}
inline void Schema::set_catalog(const char* value) {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(value);
}
inline void Schema::set_catalog(const char* value, size_t size) {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Schema::mutable_catalog() {
  set_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    catalog_ = new ::std::string;
  }
  return catalog_;
}
inline ::std::string* Schema::release_catalog() {
  clear_has_catalog();
  if (catalog_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = catalog_;
    catalog_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Schema::has_creation_timestamp() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Schema::set_has_creation_timestamp() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Schema::clear_has_creation_timestamp() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Schema::clear_creation_timestamp() {
  creation_timestamp_ = 0ULL;
  clear_has_creation_timestamp();
}
inline ::google::protobuf::uint64 Schema::creation_timestamp() const {
  return creation_timestamp_;
}
inline void Schema::set_creation_timestamp(::google::protobuf::uint64 value) {
  set_has_creation_timestamp();
  creation_timestamp_ = value;
}


inline bool Schema::has_update_timestamp() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Schema::set_has_update_timestamp() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Schema::clear_has_update_timestamp() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Schema::clear_update_timestamp() {
  update_timestamp_ = 0ULL;
  clear_has_update_timestamp();
}
inline ::google::protobuf::uint64 Schema::update_timestamp() const {
  return update_timestamp_;
}
inline void Schema::set_update_timestamp(::google::protobuf::uint64 value) {
  set_has_update_timestamp();
  update_timestamp_ = value;
}


inline bool Schema::has_uuid() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Schema::set_has_uuid() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Schema::clear_has_uuid() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Schema::clear_uuid() {
  if (uuid_ != &::google::protobuf::internal::kEmptyString) {
    uuid_->clear();
  }
  clear_has_uuid();
}
inline const ::std::string& Schema::uuid() const {
  return *uuid_;
}
inline void Schema::set_uuid(const ::std::string& value) {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  uuid_->assign(value);
}
inline void Schema::set_uuid(const char* value) {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  uuid_->assign(value);
}
inline void Schema::set_uuid(const char* value, size_t size) {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  uuid_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Schema::mutable_uuid() {
  set_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    uuid_ = new ::std::string;
  }
  return uuid_;
}
inline ::std::string* Schema::release_uuid() {
  clear_has_uuid();
  if (uuid_ == &::google::protobuf::internal::kEmptyString) {
    return __null;
  } else {
    ::std::string* temp = uuid_;
    uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
    return temp;
  }
}


inline bool Schema::has_version() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void Schema::set_has_version() {
  _has_bits_[0] |= 0x00000080u;
}
inline void Schema::clear_has_version() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void Schema::clear_version() {
  version_ = 0ULL;
  clear_has_version();
}
inline ::google::protobuf::uint64 Schema::version() const {
  return version_;
}
inline void Schema::set_version(::google::protobuf::uint64 value) {
  set_has_version();
  version_ = value;
}


inline bool Schema::has_options() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void Schema::set_has_options() {
  _has_bits_[0] |= 0x00000100u;
}
inline void Schema::clear_has_options() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void Schema::clear_options() {
  if (options_ != __null) options_->::drizzled::message::Schema_Options::Clear();
  clear_has_options();
}
inline const ::drizzled::message::Schema_Options& Schema::options() const {
  return options_ != __null ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Schema_Options* Schema::mutable_options() {
  set_has_options();
  if (options_ == __null) options_ = new ::drizzled::message::Schema_Options;
  return options_;
}
inline ::drizzled::message::Schema_Options* Schema::release_options() {
  clear_has_options();
  ::drizzled::message::Schema_Options* temp = options_;
  options_ = __null;
  return temp;
}


inline bool Schema::has_replication_options() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void Schema::set_has_replication_options() {
  _has_bits_[0] |= 0x00000200u;
}
inline void Schema::clear_has_replication_options() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void Schema::clear_replication_options() {
  if (replication_options_ != __null) replication_options_->::drizzled::message::ReplicationOptions::Clear();
  clear_has_replication_options();
}
inline const ::drizzled::message::ReplicationOptions& Schema::replication_options() const {
  return replication_options_ != __null ? *replication_options_ : *default_instance_->replication_options_;
}
inline ::drizzled::message::ReplicationOptions* Schema::mutable_replication_options() {
  set_has_replication_options();
  if (replication_options_ == __null) replication_options_ = new ::drizzled::message::ReplicationOptions;
  return replication_options_;
}
inline ::drizzled::message::ReplicationOptions* Schema::release_replication_options() {
  clear_has_replication_options();
  ::drizzled::message::ReplicationOptions* temp = replication_options_;
  replication_options_ = __null;
  return temp;
}


inline bool Schema::has_access() const {
  return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void Schema::set_has_access() {
  _has_bits_[0] |= 0x00000400u;
}
inline void Schema::clear_has_access() {
  _has_bits_[0] &= ~0x00000400u;
}
inline void Schema::clear_access() {
  if (access_ != __null) access_->::drizzled::message::Access::Clear();
  clear_has_access();
}
inline const ::drizzled::message::Access& Schema::access() const {
  return access_ != __null ? *access_ : *default_instance_->access_;
}
inline ::drizzled::message::Access* Schema::mutable_access() {
  set_has_access();
  if (access_ == __null) access_ = new ::drizzled::message::Access;
  return access_;
}
inline ::drizzled::message::Access* Schema::release_access() {
  clear_has_access();
  ::drizzled::message::Access* temp = access_;
  access_ = __null;
  return temp;
}




}
}


namespace google {
namespace protobuf {


}
}
# 26 "./drizzled/message/schema.h" 2



namespace drizzled {
namespace message {
namespace schema {

typedef message::Schema value_type;
typedef boost::shared_ptr <message::Schema> shared_ptr;
typedef const message::Schema const_reference;

shared_ptr make_shared(const identifier::Schema& identifier);
shared_ptr make_shared(const std::string &name_arg);
void init(drizzled::message::Schema &arg, const std::string &name_arg);


}
}
}
# 26 "./drizzled/message.h" 2
# 34 "./drizzled/message.h"
namespace drizzled {
namespace message {

void update(drizzled::message::Schema &arg);
void update(drizzled::message::Table &arg);

bool is_numeric(const drizzled::message::Table::Field &type);

const std::string &type(const drizzled::message::Table::Field &type);
const std::string &type(drizzled::message::Table::Field::FieldType type);
const std::string &type(drizzled::message::Table::ForeignKeyConstraint::ForeignKeyOption type);
const std::string &type(drizzled::message::Table::Index::IndexType type);
const std::string &type(drizzled::message::Table::ForeignKeyConstraint::ForeignKeyMatchOption type);
const std::string &type(drizzled::message::Table::TableType type);







}
}
# 38 "./drizzled/table/instance/base.h" 2





namespace drizzled {

const static std::string NO_PROTOBUFFER_AVAILABLE("NO PROTOBUFFER AVAILABLE");

class TableShare
{
  typedef std::vector<std::string> StringVector;

public:
  typedef boost::shared_ptr<TableShare> shared_ptr;
  typedef std::vector <shared_ptr> vector;

  TableShare(const identifier::Table::Type type_arg);

  TableShare(const identifier::Table &identifier, const identifier::Table::Key &key);

  TableShare(const identifier::Table &identifier);

  TableShare(const identifier::Table::Type type_arg,
             const identifier::Table &identifier,
             const char *path_arg= __null, uint32_t path_length_arg= 0);

  virtual ~TableShare();

private:

  enum_table_category table_category;

public:
  bool isTemporaryCategory() const
  {
    return (table_category == TABLE_CATEGORY_TEMPORARY);
  }

  void setTableCategory(enum_table_category arg)
  {
    table_category= arg;
  }


  typedef std::vector<Field *> Fields;

private:
  Fields _fields;

public:
  const Fields getFields() const
  {
    return _fields;
  }

  Fields getFields()
  {
    return _fields;
  }

  Field ** getFields(bool)
  {
    return &_fields[0];
  }

  void setFields(uint32_t arg)
  {
    _fields.resize(arg);
  }

  uint32_t positionFields(Field **arg) const
  {
    return (arg - (Field **)&_fields[0]);
  }

  void pushField(Field *arg)
  {
    _field_size++;
    _fields.push_back(arg);
  }

  Field **found_next_number_field;

private:
  Field *timestamp_field;

public:

  Field *getTimestampField() const
  {
    return timestamp_field;
  }

  void setTimestampField(Field *arg)
  {
    timestamp_field= arg;
  }


private:
  KeyInfo *key_info;

public:
  KeyInfo &getKeyInfo(uint32_t arg) const
  {
    return key_info[arg];
  }
  std::vector<uint> blob_field;

private:

  typedef boost::unordered_map<std::string, Field**, util::insensitive_hash, util::insensitive_equal_to> FieldMap;
  FieldMap name_hash;

public:
  size_t getNamedFieldSize() const
  {
    return name_hash.size();
  }

  Field **getNamedField(const std::string &arg)
  {
    return find_ptr2(name_hash, arg);
  }

private:
  memory::Root mem_root;

  unsigned char* alloc(size_t arg)
  {
    return mem_root.alloc(arg);
  }

  memory::Root& mem()
  {
    return mem_root;
  }

  typedef std::vector<std::string> keynames_t;

  keynames_t _keynames;

  void addKeyName(const std::string& arg)
  {
    _keynames.push_back(boost::to_upper_copy(arg));
  }

public:
  uint32_t doesKeyNameExist(const std::string& arg) const
  {
    keynames_t::const_iterator it= find(_keynames.begin(), _keynames.end(), boost::to_upper_copy(arg));
    return it == _keynames.end() ? (4294967295U) : it - _keynames.begin();
  }

private:
  std::vector<TYPELIB> intervals;

public:
  virtual void lock()
  { }

  virtual void unlock()
  { }

private:
  std::vector<unsigned char> default_values;

public:

  unsigned char *getDefaultValues()
  {
    return &default_values[0];
  }
  void resizeDefaultValues(size_t arg)
  {
    default_values.resize(arg);
  }

  const charset_info_st *table_charset;

  boost::dynamic_bitset<> all_set;
# 231 "./drizzled/table/instance/base.h"
private:
  identifier::Table::Key private_key_for_cache;
  std::vector<char> private_normalized_path;
  str_ref db;
  str_ref table_name;
  str_ref path;
  str_ref normalized_path;

public:

  const char *getNormalizedPath() const
  {
    return normalized_path.data();
  }

  const char *getPath() const
  {
    return path.data();
  }

  const identifier::Table::Key& getCacheKey() const
  {
    ((private_key_for_cache.size()) ? static_cast<void> (0) : __assert_fail ("private_key_for_cache.size()", "./drizzled/table/instance/base.h", 253, __PRETTY_FUNCTION__));
    return private_key_for_cache;
  }

  size_t getCacheKeySize() const
  {
    return private_key_for_cache.size();
  }

  str_ref getTableNameRef() const
  {
    return table_name;
  }

  const char *getTableName() const
  {
    return table_name.data();
  }

  str_ref getSchemaNameRef() const
  {
    return db;
  }

  const char *getSchemaName() const
  {
    return db.data();
  }

  uint32_t block_size;

private:
  uint64_t version;

public:
  uint64_t getVersion() const
  {
    return version;
  }

  void refreshVersion();

  void resetVersion()
  {
    version= 0;
  }

private:
  uint32_t timestamp_offset;

  uint32_t reclength;
  uint32_t stored_rec_length;

public:
  uint32_t sizeStoredRecord() const
  {
    return stored_rec_length;
  }

  uint32_t getRecordLength() const
  {
    return reclength;
  }

  void setRecordLength(uint32_t arg)
  {
    reclength= arg;
  }

  const Field_blob *getBlobFieldAt(uint32_t arg) const
  {
    if (arg < blob_fields)
      return (Field_blob*) _fields[blob_field[arg]];

    return __null;
  }

private:

  uint64_t max_rows;

  boost::scoped_ptr<message::Table> _table_message;

public:




  message::Table::TableType getTableType() const
  {
    return getTableMessage() ? getTableMessage()->type() : message::Table::STANDARD;
  }

  const std::string &getTableTypeAsString() const
  {
    if (getTableMessage())
      return message::type(getTableMessage()->type());

    return NO_PROTOBUFFER_AVAILABLE;
  }


  inline message::Table *getTableMessage() const
  {
    return _table_message.get();
  }

  void setTableMessage(const message::Table &arg)
  {
    ((not getTableMessage()) ? static_cast<void> (0) : __assert_fail ("not getTableMessage()", "./drizzled/table/instance/base.h", 362, __PRETTY_FUNCTION__));
    _table_message.reset(new message::Table(arg));
  }

  const message::Table::Field &field(int32_t field_position) const
  {
    ((getTableMessage()) ? static_cast<void> (0) : __assert_fail ("getTableMessage()", "./drizzled/table/instance/base.h", 368, __PRETTY_FUNCTION__));
    return getTableMessage()->field(field_position);
  }

  inline bool hasComment() const
  {
    return getTableMessage() ? getTableMessage()->options().has_comment() : false;
  }

  inline const char *getComment()
  {
    return (getTableMessage() && getTableMessage()->has_options()) ? getTableMessage()->options().comment().c_str() : __null;
  }

  inline uint32_t getCommentLength() const
  {
    return (getTableMessage()) ? getTableMessage()->options().comment().length() : 0;
  }

  inline uint64_t getMaxRows() const
  {
    return max_rows;
  }

  inline void setMaxRows(uint64_t arg)
  {
    max_rows= arg;
  }





  bool fieldInPrimaryKey(Field *field) const;

  plugin::StorageEngine *storage_engine;
  inline plugin::StorageEngine *db_type() const
  {
    return storage_engine;
  }
  inline plugin::StorageEngine *getEngine() const
  {
    return storage_engine;
  }

private:
  identifier::Table::Type tmp_table;
public:

  identifier::Table::Type getType() const
  {
    return tmp_table;
  }

private:
  uint32_t _ref_count;

public:
  uint32_t getTableCount() const
  {
    return _ref_count;
  }

  void incrementTableCount()
  {
    lock();
    _ref_count++;
    unlock();
  }

  uint32_t decrementTableCount()
  {
    return --_ref_count;
  }

  uint32_t null_bytes;
  uint32_t last_null_bit_pos;
private:
  uint32_t _field_size;

public:
  void setFieldSize(uint32_t arg)
  {
    _field_size= arg;
  }

  uint32_t sizeFields() const
  {
    return _field_size;
  }

  uint32_t rec_buff_length;
  uint32_t keys;

  uint32_t sizeKeys() const
  {
    return keys;
  }
  uint32_t key_parts;
  uint32_t max_key_length, max_unique_length, total_key_length;
  uint32_t uniques;
  uint32_t null_fields;
  uint32_t blob_fields;
private:
  bool has_variable_width;

public:
  bool hasVariableWidth() const
  {
    return has_variable_width;
  }
  void setVariableWidth()
  {
    has_variable_width= true;
  }
  uint32_t db_create_options;
  uint32_t db_options_in_use;
  uint32_t db_record_offset;
  uint32_t rowid_field_offset;
# 496 "./drizzled/table/instance/base.h"
private:
  uint32_t primary_key;
public:

  uint32_t getPrimaryKey() const
  {
    return primary_key;
  }

  bool hasPrimaryKey() const
  {
    return primary_key != MAX_KEY;
  }


  uint32_t next_number_index;
  uint32_t next_number_key_offset;
  uint32_t next_number_keypart;
  uint32_t error, open_errno, errarg;

private:
  uint8_t blob_ptr_size;

public:
  uint8_t sizeBlobPtr() const
  {
    return blob_ptr_size;
  }

  bool db_low_byte_first;





  key_map keys_in_use;
  key_map keys_for_keyread;





  virtual plugin::EventObserverList *getTableObservers()
  {
    return __null;
  }

  virtual void setTableObservers(plugin::EventObserverList *)
  { }
# 555 "./drizzled/table/instance/base.h"
  void setIdentifier(const identifier::Table &identifier_arg);
# 573 "./drizzled/table/instance/base.h"
private:
  void init(const char *new_table_name,
            const char *new_path);

protected:
  void open_table_error(int pass_error, int db_errno, int pass_errarg);

public:

  static TableShare::shared_ptr getShareCreate(Session*, const identifier::Table&, int &error);

  friend std::ostream& operator<<(std::ostream& output, const TableShare &share)
  {
    return output << "TableShare:(" << share.getSchemaNameRef() << ", " << share.getTableName() << ", " << share.getTableTypeAsString() << ", " << share.getPath() << ")";
  }

protected:
  friend class drizzled::table::Singular;

  Field *make_field(const message::Table::Field &pfield,
                    unsigned char *ptr,
                    uint32_t field_length,
                    bool is_nullable,
                    unsigned char *null_pos,
                    unsigned char null_bit,
                    uint8_t decimals,
                    enum_field_types field_type,
                    const charset_info_st * field_charset,
                    Field::utype unireg_check,
                    TYPELIB *interval,
                    const char *field_name);

  Field *make_field(const message::Table::Field &pfield,
                    unsigned char *ptr,
                    uint32_t field_length,
                    bool is_nullable,
                    unsigned char *null_pos,
                    unsigned char null_bit,
                    uint8_t decimals,
                    enum_field_types field_type,
                    const charset_info_st * field_charset,
                    Field::utype unireg_check,
                    TYPELIB *interval,
                    const char *field_name,
                    bool is_unsigned);

public:
  int open_table_def(Session& session, const identifier::Table &identifier);

  int open_table_from_share(Session *session,
                            const identifier::Table &identifier,
                            const char *alias,
                            uint32_t db_stat, uint32_t ha_open_flags,
                            Table &outparam);
private:
  int open_table_from_share_inner(Session *session,
                                  const char *alias,
                                  uint32_t db_stat,
                                  Table &outparam);
  int open_table_cursor_inner(const identifier::Table &identifier,
                              uint32_t db_stat, uint32_t ha_open_flags,
                              Table &outparam,
                              bool &error_reported);
public:
  bool parse_table_proto(Session& session, const message::Table &table);

  virtual bool is_replicated() const
  {
    return false;
  }
};

}
# 25 "./drizzled/table/instance.h" 2
# 1 "./drizzled/table/instance/shared.h" 1
# 22 "./drizzled/table/instance/shared.h"
       



namespace drizzled {
namespace table {
namespace instance {

void release(TableShare *share);
void release(TableShare::shared_ptr &share);
void release(const identifier::Table &identifier);


class Shared : public drizzled::TableShare
{
  friend void release(TableShare *share);
  friend void release(TableShare::shared_ptr &share);

public:
  typedef boost::shared_ptr<Shared> shared_ptr;
  typedef std::vector <shared_ptr> vector;

  Shared(const identifier::Table::Type type_arg,
         const identifier::Table &identifier,
         char *path_arg= __null, uint32_t path_length_arg= 0);

  Shared(const identifier::Table &identifier, message::schema::shared_ptr schema_message);

  Shared(const identifier::Table &identifier);

  ~Shared();


  void lock()
  {
    mutex.lock();
  }

  void unlock()
  {
    mutex.unlock();
  }

  static shared_ptr make_shared(Session *session,
                                const identifier::Table &identifier,
                                int &in_error);

  static shared_ptr foundTableShare(shared_ptr share);

  plugin::EventObserverList *getTableObservers()
  {
    return event_observers;
  }

  void setTableObservers(plugin::EventObserverList *observers)
  {
    event_observers= observers;
  }

  virtual bool is_replicated() const;

private:
  boost::mutex mutex;
  drizzled::message::schema::shared_ptr _schema;





  plugin::EventObserverList *event_observers;

};

}
}
}
# 26 "./drizzled/table/instance.h" 2
# 1 "./drizzled/table/instance/singular.h" 1
# 22 "./drizzled/table/instance/singular.h"
       



namespace drizzled {
namespace table {
namespace instance {

class Singular : public drizzled::TableShare
{
public:

  Singular(const identifier::Table::Type type_arg,
           const identifier::Table &identifier,
           const char *path_arg= __null, uint32_t path_length_arg= 0);

  ~Singular();
};

}
}
}
# 26 "./drizzled/table/instance.h" 2
# 33 "./drizzled/table.h" 2




namespace drizzled {





class __attribute__ ((visibility("default"))) Table
{
  Field **field;

public:
  Field **getFields() const
  {
    return field;
  }

  Field *getField(uint32_t arg) const
  {
    return field[arg];
  }

  void setFields(Field **arg)
  {
    field= arg;
  }

  void setFieldAt(Field *arg, uint32_t arg_pos)
  {
    field[arg_pos]= arg;
  }

  Cursor *cursor;

private:
  Table *next;

public:
  Table *getNext() const
  {
    return next;
  }

  Table **getNextPtr()
  {
    return &next;
  }

  void setNext(Table *arg)
  {
    next= arg;
  }

  void unlink()
  {
    getNext()->setPrev(getPrev());
    getPrev()->setNext(getNext());
  }

private:
  Table *prev;
public:
  Table *getPrev() const
  {
    return prev;
  }

  Table **getPrevPtr()
  {
    return &prev;
  }

  void setPrev(Table *arg)
  {
    prev= arg;
  }

  boost::dynamic_bitset<> *read_set;
  boost::dynamic_bitset<> *write_set;

  uint32_t tablenr;
  uint32_t db_stat;

  boost::dynamic_bitset<> def_read_set;
  boost::dynamic_bitset<> def_write_set;
  boost::dynamic_bitset<> tmp_set;

  Session *in_use;
  Session *getSession()
  {
    return in_use;
  }

  unsigned char *getInsertRecord() const
  {
    return record[0];
  }

  unsigned char *getUpdateRecord()
  {
    return record[1];
  }

  unsigned char *record[2];
  std::vector<unsigned char> insert_values;
  KeyInfo *key_info;
  Field *next_number_field;
  Field *found_next_number_field;
  field::Epoch *timestamp_field;

  TableList *pos_in_table_list;
  Order *group;

  const char *getAlias() const
  {
    return _alias.c_str();
  }

  void clearAlias()
  {
    _alias.clear();
  }

  void setAlias(const char *arg)
  {
    _alias= arg;
  }

private:
  std::string _alias;
public:

  unsigned char *null_flags;

  uint32_t lock_position;
  uint32_t lock_data_start;
  uint32_t lock_count;
  uint32_t used_fields;
  uint32_t status;

  uint32_t derived_select_number;
  int current_lock;
  bool copy_blobs;






  bool maybe_null;





  bool null_row;

  bool force_index;
  bool distinct;
  bool const_table;
  bool no_rows;
  bool key_read;
  bool no_keyread;
# 216 "./drizzled/table.h"
  bool open_placeholder;
  bool locked_by_name;
  bool no_cache;





  bool auto_increment_field_not_null;
  bool alias_name_used;
# 245 "./drizzled/table.h"
  query_id_t query_id;
# 255 "./drizzled/table.h"
  ha_rows quick_condition_rows;
# 269 "./drizzled/table.h"
  timestamp_auto_set_type timestamp_field_type;
  table_map map;

  RegInfo reginfo;





  key_map covering_keys;
  key_map quick_keys;
  key_map merge_keys;
# 293 "./drizzled/table.h"
  key_map keys_in_use_for_query;


  key_map keys_in_use_for_group_by;


  key_map keys_in_use_for_order_by;





  ha_rows quick_rows[MAX_KEY];


  key_part_map const_key_parts[MAX_KEY];

  uint32_t quick_key_parts[MAX_KEY];
  uint32_t quick_n_ranges[MAX_KEY];

private:
  memory::Root mem_root;

  void init_mem_root()
  {
    if (not mem_root.alloc_root_inited())
      mem_root.init(1024);
  }
public:
  memory::Root& mem()
  {
    init_mem_root();
    return mem_root;
  }

  unsigned char* alloc(size_t arg)
  {
    init_mem_root();
    return mem_root.alloc(arg);
  }

  char* strdup(const char* str_arg, size_t len_arg)
  {
    init_mem_root();
    return mem_root.strdup(str_arg, len_arg);
  }

  filesort_info sort;

  Table();
  virtual ~Table();

  int report_error(int error);






  int delete_table(bool free_share= false);

  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg);


  virtual const TableShare *getShare() const= 0;
  virtual TableShare *getMutableShare()= 0;
  virtual bool hasShare() const= 0;
  virtual void setShare(TableShare *new_share)= 0;

  virtual void release(void)= 0;

  uint32_t sizeKeys() { return getMutableShare()->sizeKeys(); }
  uint32_t sizeFields() { return getMutableShare()->sizeFields(); }
  uint32_t getRecordLength() const { return getShare()->getRecordLength(); }
  uint32_t sizeBlobFields() { return getMutableShare()->blob_fields; }
  uint32_t *getBlobField() { return &getMutableShare()->blob_field[0]; }

public:
  virtual bool hasVariableWidth() const
  {
    return getShare()->hasVariableWidth();
  }

  virtual void setVariableWidth(void);

  Field_blob *getBlobFieldAt(uint32_t arg) const
  {
    if (arg < getShare()->blob_fields)
      return (Field_blob*) field[getShare()->blob_field[arg]];

    return __null;
  }
  inline uint8_t getBlobPtrSize() const { return getShare()->sizeBlobPtr(); }
  inline uint32_t getNullBytes() const { return getShare()->null_bytes; }
  inline uint32_t getNullFields() const { return getShare()->null_fields; }
  inline unsigned char *getDefaultValues() { return getMutableShare()->getDefaultValues(); }
  inline const char *getSchemaName() const { return getShare()->getSchemaName(); }
  inline const char *getTableName() const { return getShare()->getTableName(); }

  inline bool isDatabaseLowByteFirst() const { return getShare()->db_low_byte_first; }
  inline bool isNameLock() const { return open_placeholder; }

  uint32_t index_flags(uint32_t idx) const;

  inline plugin::StorageEngine *getEngine() const
  {
    return getShare()->getEngine();
  }

  Cursor &getCursor() const
  {
    ((cursor) ? static_cast<void> (0) : __assert_fail ("cursor", "./drizzled/table.h", 404, __PRETTY_FUNCTION__));
    return *cursor;
  }

  size_t max_row_length(const unsigned char *data);
  uint32_t find_shortest_key(const key_map *usable_keys);
  bool compare_record(Field **ptr);
  bool records_are_comparable();
  bool compare_records();

  void storeRecord();
  void storeRecordAsInsert();
  void storeRecordAsDefault();
  void restoreRecord();
  void restoreRecordAsDefault();
  void emptyRecord();



  inline uint32_t getDBStat () const { return db_stat; }
# 441 "./drizzled/table.h"
  void fill_item_list(List<Item>&) const;
  void clear_column_bitmaps(void);
  void prepare_for_position(void);
  void mark_columns_used_by_index_no_reset(uint32_t index, boost::dynamic_bitset<>& bitmap);
  void mark_columns_used_by_index_no_reset(uint32_t index);
  void mark_columns_used_by_index(uint32_t index);
  void restore_column_maps_after_mark_index();
  void mark_auto_increment_column(void);
  void mark_columns_needed_for_update(void);
  void mark_columns_needed_for_delete(void);
  void mark_columns_needed_for_insert(void);
  void column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
                          boost::dynamic_bitset<>& write_set_arg);

  void restore_column_map(const boost::dynamic_bitset<>& old);

  const boost::dynamic_bitset<> use_all_columns(boost::dynamic_bitset<>& map);
  inline void use_all_columns()
  {
    column_bitmaps_set(getMutableShare()->all_set, getMutableShare()->all_set);
  }

  inline void default_column_bitmaps()
  {
    read_set= &def_read_set;
    write_set= &def_write_set;
  }


  inline bool isReadSet(uint32_t index) const
  {
    return read_set->test(index);
  }

  inline void setReadSet(uint32_t index)
  {
    read_set->set(index);
  }

  inline void setReadSet()
  {
    read_set->set();
  }

  inline void clearReadSet(uint32_t index)
  {
    read_set->reset(index);
  }

  inline void clearReadSet()
  {
    read_set->reset();
  }

  inline bool isWriteSet(uint32_t index)
  {
    return write_set->test(index);
  }

  inline void setWriteSet(uint32_t index)
  {
    write_set->set(index);
  }

  inline void setWriteSet()
  {
    write_set->set();
  }

  inline void clearWriteSet(uint32_t index)
  {
    write_set->reset(index);
  }

  inline void clearWriteSet()
  {
    write_set->reset();
  }


  bool is_name_opened() const
  {
    return db_stat || open_placeholder;
  }




  bool needs_reopen_or_name_lock() const;
# 538 "./drizzled/table.h"
  void setup_table_map(TableList *table_list, uint32_t tablenr);
  inline void mark_as_null_row()
  {
    null_row= 1;
    status|= 32;
    memset(null_flags, 255, getShare()->null_bytes);
  }

  void free_io_cache();
  void filesort_free_buffers(bool full= false);
  void intern_close_table();

  void print_error(int error, myf errflag) const;





  uint32_t get_dup_key(int error) const
  {
    cursor->errkey = (uint32_t) -1;
    if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOREIGN_DUPLICATE_KEY ||
        error == HA_ERR_FOUND_DUPP_UNIQUE ||
        error == HA_ERR_DROP_INDEX_FK)
      cursor->info(32 | 2);

    return(cursor->errkey);
  }




  bool operator<(const Table &right) const
  {
    return getShare()->getCacheKey() < right.getShare()->getCacheKey();
  }

  static bool compare(const Table *a, const Table *b)
  {
    return *a < *b;
  }

  friend std::ostream& operator<<(std::ostream& output, const Table &table)
  {
    if (table.getShare())
    {
      output << "Table:(";
      output << table.getShare()->getSchemaName();
      output << ", ";
      output << table.getShare()->getTableName();
      output << ", ";
      output << table.getShare()->getTableTypeAsString();
      output << ")";
    }
    else
    {
      output << "Table:(has no share)";
    }

    return output;
  }

public:
  virtual bool isPlaceHolder(void) const
  {
    return false;
  }
};
# 614 "./drizzled/table.h"
class ForeignKeyInfo
{
public:
# 630 "./drizzled/table.h"
    ForeignKeyInfo(lex_string_t *in_foreign_id,
                   lex_string_t *in_referenced_db,
                   lex_string_t *in_referenced_table,
                   lex_string_t *in_update_method,
                   lex_string_t *in_delete_method,
                   lex_string_t *in_referenced_key_name,
                   List<lex_string_t> in_foreign_fields,
                   List<lex_string_t> in_referenced_fields)
    :
      foreign_id(in_foreign_id),
      referenced_db(in_referenced_db),
      referenced_table(in_referenced_table),
      update_method(in_update_method),
      delete_method(in_delete_method),
      referenced_key_name(in_referenced_key_name),
      foreign_fields(in_foreign_fields),
      referenced_fields(in_referenced_fields)
    {}





    ForeignKeyInfo()
    : foreign_id(__null), referenced_db(__null), referenced_table(__null),
      update_method(__null), delete_method(__null), referenced_key_name(__null)
    {}







    const lex_string_t *getForeignId() const
    {
        return foreign_id;
    }







    const lex_string_t *getReferencedDb() const
    {
        return referenced_db;
    }







    const lex_string_t *getReferencedTable() const
    {
        return referenced_table;
    }







    const lex_string_t *getUpdateMethod() const
    {
        return update_method;
    }







    const lex_string_t *getDeleteMethod() const
    {
        return delete_method;
    }







    const lex_string_t *getReferencedKeyName() const
    {
        return referenced_key_name;
    }







    const List<lex_string_t> &getForeignFields() const
    {
        return foreign_fields;
    }







    const List<lex_string_t> &getReferencedFields() const
    {
        return referenced_fields;
    }
private:



    lex_string_t *foreign_id;



    lex_string_t *referenced_db;



    lex_string_t *referenced_table;



    lex_string_t *update_method;



    lex_string_t *delete_method;



    lex_string_t *referenced_key_name;



    List<lex_string_t> foreign_fields;



    List<lex_string_t> referenced_fields;
};




void free_blobs(Table *table);
int set_zone(int nr,int min_zone,int max_zone);
uint32_t convert_period_to_month(uint32_t period);
uint32_t convert_month_to_period(uint32_t month);

int test_if_number(char *str,int *res,bool allow_wildcards);
void change_byte(unsigned char *,uint,char,char);
void change_double_for_sort(double nr,unsigned char *to);
int get_quick_record(optimizer::SqlSelect *select);

void find_date(char *pos,uint32_t *vek,uint32_t flag);
TYPELIB* convert_strings_to_array_type(char** typelibs, char** end);
TYPELIB* typelib(memory::Root&, List<String>&);
ulong get_form_pos(int file, unsigned char *head, TYPELIB *save_names);
void append_unescaped(String *res, const char *pos, uint32_t length);

bool check_column_name(const char*);
bool check_table_name(str_ref);

}

# 1 "./drizzled/table/singular.h" 1
# 23 "./drizzled/table/singular.h"
       

namespace drizzled {
namespace table {

class Singular : public Table
{
  TableShare _share;
  bool _has_variable_width;

public:
  Singular() :
    _share(message::Table::INTERNAL),
    _has_variable_width(false)
  {
  }

  Singular(Session *session, std::list<CreateField>&);

  TableShare *getMutableShare()
  {
    return &_share;
  }

  void setShare(TableShare *)
  {
    ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/table/singular.h", 49, __PRETTY_FUNCTION__));
  }

  const TableShare *getShare() const
  {
    return &_share;
  }

  bool hasShare() const { return true; }

  void release() {};

  bool hasVariableWidth() const
  {
    return _has_variable_width;
  }

  bool create_myisam_tmp_table(KeyInfo *keyinfo,
                               MI_COLUMNDEF *start_recinfo,
                               MI_COLUMNDEF **recinfo,
                               uint64_t options);
  void setup_tmp_table_column_bitmaps();
  bool open_tmp_table();

  void setVariableWidth()
  {
    _has_variable_width= true;
  }

  ~Singular();
};

}
}
# 805 "./drizzled/table.h" 2
# 1 "./drizzled/table/concurrent.h" 1
# 21 "./drizzled/table/concurrent.h"
       

namespace drizzled
{

namespace table
{

class Concurrent : public Table
{
  TableShare *_share;

public:
  Concurrent() :
    Table()
  {
  }

  ~Concurrent()
  {
  }

  virtual const TableShare *getShare() const { ((_share) ? static_cast<void> (0) : __assert_fail ("_share", "./drizzled/table/concurrent.h", 43, __PRETTY_FUNCTION__)); return _share; }
  virtual TableShare *getMutableShare() { ((_share) ? static_cast<void> (0) : __assert_fail ("_share", "./drizzled/table/concurrent.h", 44, __PRETTY_FUNCTION__)); return _share; }
  virtual bool hasShare() const { return _share ? true : false ; }
  virtual void setShare(TableShare *new_share) { _share= new_share; }

  int open_unireg_entry(Session *session,
                        const char *alias,
                        identifier::Table &identifier);
  bool reopen_name_locked_table(TableList* table_list, Session *session);
  virtual void release(void);
};

}
}
# 806 "./drizzled/table.h" 2
# 25 "./drizzled/table_list.h" 2

namespace drizzled {
# 58 "./drizzled/table_list.h"
class TableList
{
public:
  TableList():
    next_local(__null),
    next_global(__null),
    prev_global(__null),
    schema(__null),
    alias(__null),
    table_name(__null),
    option(__null),
    on_expr(__null),
    table(__null),
    prep_on_expr(__null),
    cond_equal(__null),
    natural_join(__null),
    is_natural_join(false),
    is_join_columns_complete(false),
    straight(false),
    force_index(false),
    ignore_leaves(false),
    join_using_fields(__null),
    join_columns(__null),
    next_name_resolution_table(__null),
    index_hints(__null),
    derived_result(__null),
    derived(__null),
    schema_select_lex(__null),
    select_lex(__null),
    next_leaf(__null),
    outer_join(0),
    dep_tables(0),
    on_expr_dep_tables(0),
    nested_join(__null),
    embedding(__null),
    join_list(__null),
    db_type(__null),
    internal_tmp_table(false),
    is_alias(false),
    is_fqtn(false),
    create(false)
  {
  }






  TableList *next_local;


  TableList *next_global;
  TableList **prev_global;

private:
  const char* schema;

public:
  const char *getSchemaName() const
  {
    return schema;
  }

  void setSchemaName(const char* v)
  {
    schema= v;
  }

  const char *alias;

private:
  const char* table_name;

public:
  const char *getTableName() const
  {
    return table_name;
  }

  void setTableName(const char* v)
  {
    table_name= v;
  }

  const char *option;
  Item *on_expr;
  Table *table;
# 154 "./drizzled/table_list.h"
  Item *prep_on_expr;
  COND_EQUAL *cond_equal;






  TableList *natural_join;





  bool is_natural_join;


  bool is_join_columns_complete;

  bool straight;
  bool force_index;
  bool ignore_leaves;




  bool isCartesian() const;


  List<String> *join_using_fields;




  List<Natural_join_column> *join_columns;
# 197 "./drizzled/table_list.h"
  TableList *next_name_resolution_table;

  List<Index_hint> *index_hints;




  select_union *derived_result;
  Select_Lex_Unit *derived;
  Select_Lex *schema_select_lex;

  Select_Lex *select_lex;





  TableList *next_leaf;
  thr_lock_type lock_type;
  uint32_t outer_join;

  void set_underlying_merge();
  bool setup_underlying(Session *session);





  bool placeholder();





  void print(Session *session, String *str);
# 242 "./drizzled/table_list.h"
  void set_insert_values();
# 254 "./drizzled/table_list.h"
  TableList *find_underlying_table(Table *table);
# 270 "./drizzled/table_list.h"
  TableList *first_leaf_for_name_resolution();
# 286 "./drizzled/table_list.h"
  TableList *last_leaf_for_name_resolution();
# 301 "./drizzled/table_list.h"
  bool is_leaf_for_name_resolution() const;
  inline TableList *top_table()
  { return this; }
# 314 "./drizzled/table_list.h"
  Item_subselect *containing_subselect();
# 368 "./drizzled/table_list.h"
  bool process_index_hints(Table *table);

  friend std::ostream& operator<<(std::ostream& output, const TableList &list)
  {
    output << "TableList:(";
    output << list.getSchemaName();
    output << ", ";
    output << list.getTableName();
    output << ", ";
    output << list.alias;
    output << ", ";
    output << "is_natural_join:" << list.is_natural_join;
    output << ", ";
    output << "is_join_columns_complete:" << list.is_join_columns_complete;
    output << ", ";
    output << "straight:" << list.straight;
    output << ", ";
    output << "force_index" << list.force_index;
    output << ", ";
    output << "ignore_leaves:" << list.ignore_leaves;
    output << ", ";
    output << "create:" << list.create;
    output << ", ";
    output << "outer_join:" << list.outer_join;
    output << ", ";
    output << "nested_join:" << list.nested_join;
    output << ")";

    return output;
  }

  void setIsAlias(bool in_is_alias)
  {
    is_alias= in_is_alias;
  }

  void setIsFqtn(bool in_is_fqtn)
  {
    is_fqtn= in_is_fqtn;
  }

  void setCreate(bool in_create)
  {
    create= in_create;
  }

  void setInternalTmpTable(bool in_internal_tmp_table)
  {
    internal_tmp_table= in_internal_tmp_table;
  }

  void setDbType(plugin::StorageEngine *in_db_type)
  {
    db_type= in_db_type;
  }

  void setJoinList(List<TableList> *in_join_list)
  {
    join_list= in_join_list;
  }

  void setEmbedding(TableList *in_embedding)
  {
    embedding= in_embedding;
  }

  void setNestedJoin(NestedJoin *in_nested_join)
  {
    nested_join= in_nested_join;
  }

  void setDepTables(table_map in_dep_tables)
  {
    dep_tables= in_dep_tables;
  }

  void setOnExprDepTables(table_map in_on_expr_dep_tables)
  {
    on_expr_dep_tables= in_on_expr_dep_tables;
  }

  bool getIsAlias() const
  {
    return is_alias;
  }

  bool getIsFqtn() const
  {
    return is_fqtn;
  }

  bool isCreate() const
  {
    return create;
  }

  bool getInternalTmpTable() const
  {
    return internal_tmp_table;
  }

  plugin::StorageEngine *getDbType() const
  {
    return db_type;
  }

  TableList *getEmbedding() const
  {
    return embedding;
  }

  List<TableList> *getJoinList() const
  {
    return join_list;
  }

  NestedJoin *getNestedJoin() const
  {
    return nested_join;
  }

  table_map getDepTables() const
  {
    return dep_tables;
  }

  table_map getOnExprDepTables() const
  {
    return on_expr_dep_tables;
  }

  void unlock_table_name();
  void unlock_table_names(TableList *last_table= __null);

private:
  table_map dep_tables;
  table_map on_expr_dep_tables;
  NestedJoin *nested_join;
  TableList *embedding;
  List<TableList> *join_list;
  plugin::StorageEngine *db_type;
  bool internal_tmp_table;


  bool is_alias;





  bool is_fqtn;






  bool create;

};

void close_thread_tables(Session *session);

}
# 28 "./drizzled/sql_lex.h" 2
# 1 "./drizzled/function/math/real.h" 1
# 20 "./drizzled/function/math/real.h"
       





namespace drizzled
{

class __attribute__ ((visibility("default"))) Item_real_func :
  public Item_func
{
public:
  Item_real_func() :Item_func() {}
  Item_real_func(Item *a) :Item_func(a) {}
  Item_real_func(Item *a,Item *b) :Item_func(a,b) {}
  Item_real_func(List<Item> &list) :Item_func(list) {}
  String *val_str(String*str);
  type::Decimal *val_decimal(type::Decimal *decimal_value);
  int64_t val_int();
  enum Item_result result_type () const { return REAL_RESULT; }
  void fix_length_and_dec();
};

}
# 29 "./drizzled/sql_lex.h" 2
# 1 "./drizzled/key_part_spec.h" 1
# 21 "./drizzled/key_part_spec.h"
       




namespace drizzled {

class Key_part_spec : public memory::SqlAlloc
{
public:
  str_ref field_name;
  uint32_t length;
  Key_part_spec(str_ref name, uint32_t len)
    : field_name(name), length(len)
  {}

  bool operator==(const Key_part_spec& other) const;
# 47 "./drizzled/key_part_spec.h"
  Key_part_spec *clone(memory::Root *mem_root) const
  {
    return new (*mem_root) Key_part_spec(*this);
  }
};

}
# 30 "./drizzled/sql_lex.h" 2
# 1 "./drizzled/index_hint.h" 1
# 27 "./drizzled/index_hint.h"
       

namespace drizzled {





extern const char* index_hint_type_name[];
typedef unsigned char index_clause_map;

enum index_hint_type
{
  INDEX_HINT_IGNORE,
  INDEX_HINT_USE,
  INDEX_HINT_FORCE
};
# 56 "./drizzled/index_hint.h"
class Index_hint : public memory::SqlAlloc
{
public:

  index_hint_type type;

  index_clause_map clause;




  const char* key_name;

  Index_hint(index_hint_type type_arg, index_clause_map clause_arg, const char *str) :
    type(type_arg), clause(clause_arg), key_name(str)
  {
  }

  void print(String&) const;
};

}
# 31 "./drizzled/sql_lex.h" 2
# 1 "./drizzled/optimizer/explain_plan.h" 1
# 20 "./drizzled/optimizer/explain_plan.h"
       

namespace drizzled {
namespace optimizer {


enum select_type
{
  ST_PRIMARY,
  ST_SIMPLE,
  ST_DERIVED,
  ST_DEPENDENT_SUBQUERY,
  ST_UNCACHEABLE_SUBQUERY,
  ST_SUBQUERY,
 ST_DEPENDENT_UNION,
  ST_UNCACHEABLE_UNION,
  ST_UNION,
  ST_UNION_RESULT
};

class ExplainPlan
{
public:

  ExplainPlan()
    :
      join(__null),
      need_tmp_table(false),
      need_order(false),
      distinct(false),
      message(__null)
  {}

  ExplainPlan(Join *in_join,
              bool in_need_tmp_table,
              bool in_need_order,
              bool in_distinct,
              const char *in_message)
    :
      join(in_join),
      need_tmp_table(in_need_tmp_table),
      need_order(in_need_order),
      distinct(in_distinct),
      message(in_message)
  {}

  void printPlan();

  bool explainUnion(Session *session,
                    Select_Lex_Unit *unit,
                    select_result *result);

private:

  Join *join;

  bool need_tmp_table;

  bool need_order;

  bool distinct;

  const char *message;
};

}

}
# 32 "./drizzled/sql_lex.h" 2
# 43 "./drizzled/sql_lex.h"
# 1 "./drizzled/sys_var.h" 1
# 20 "./drizzled/sys_var.h"
       


# 1 "/usr/include/boost/filesystem.hpp" 1 3 4
# 15 "/usr/include/boost/filesystem.hpp" 3 4
# 1 "/usr/include/boost/filesystem/config.hpp" 1 3 4
# 106 "/usr/include/boost/filesystem/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 107 "/usr/include/boost/filesystem/config.hpp" 2 3 4
# 16 "/usr/include/boost/filesystem.hpp" 2 3 4
# 1 "/usr/include/boost/filesystem/path.hpp" 1 3 4
# 25 "/usr/include/boost/filesystem/path.hpp" 3 4
# 1 "/usr/include/boost/filesystem/path_traits.hpp" 1 3 4
# 24 "/usr/include/boost/filesystem/path_traits.hpp" 3 4
# 1 "/usr/include/c++/4.8/cwchar" 1 3 4
# 39 "/usr/include/c++/4.8/cwchar" 3 4
       
# 40 "/usr/include/c++/4.8/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/usr/include/c++/4.8/cwchar" 2 3
# 25 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4





# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 31 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4


# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 34 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4

namespace boost { namespace filesystem {

  const system::error_category& codecvt_error_category();
# 48 "/usr/include/boost/filesystem/path_traits.hpp" 3 4
  class directory_entry;

namespace path_traits {

  typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type;



  template <class T>
  struct is_pathable { static const bool value = false; };

  template<> struct is_pathable<char*> { static const bool value = true; };
  template<> struct is_pathable<const char*> { static const bool value = true; };
  template<> struct is_pathable<wchar_t*> { static const bool value = true; };
  template<> struct is_pathable<const wchar_t*> { static const bool value = true; };
  template<> struct is_pathable<std::string> { static const bool value = true; };
  template<> struct is_pathable<std::wstring> { static const bool value = true; };
  template<> struct is_pathable<std::vector<char> > { static const bool value = true; };
  template<> struct is_pathable<std::vector<wchar_t> > { static const bool value = true; };
  template<> struct is_pathable<std::list<char> > { static const bool value = true; };
  template<> struct is_pathable<std::list<wchar_t> > { static const bool value = true; };
  template<> struct is_pathable<directory_entry> { static const bool value = true; };



  template <class Container> inline


    typename boost::disable_if<boost::is_array<Container>, bool>::type
      empty(const Container & c)
        { return c.begin() == c.end(); }

  template <class T> inline
    bool empty(T * const & c_str)
  {
    ((c_str) ? static_cast<void> (0) : __assert_fail ("c_str", "/usr/include/boost/filesystem/path_traits.hpp", 83, __PRETTY_FUNCTION__));
    return !*c_str;
  }

  template <typename T, size_t N> inline
     bool empty(T (&x)[N])
       { return !x[0]; }





 
  void convert(const char* from,
                const char* from_end,
                std::wstring & to,
                const codecvt_type& cvt);

 
  void convert(const wchar_t* from,
                const wchar_t* from_end,
                std::string & to,
                const codecvt_type& cvt);

  inline
  void convert(const char* from,
                std::wstring & to,
                const codecvt_type& cvt)
  {
    ((from) ? static_cast<void> (0) : __assert_fail ("from", "/usr/include/boost/filesystem/path_traits.hpp", 112, __PRETTY_FUNCTION__));
    convert(from, 0, to, cvt);
  }

  inline
  void convert(const wchar_t* from,
                std::string & to,
                const codecvt_type& cvt)
  {
    ((from) ? static_cast<void> (0) : __assert_fail ("from", "/usr/include/boost/filesystem/path_traits.hpp", 121, __PRETTY_FUNCTION__));
    convert(from, 0, to, cvt);
  }





  inline
  void convert(const char* from, const char* from_end, std::string & to,
    const codecvt_type&)
  {
    ((from) ? static_cast<void> (0) : __assert_fail ("from", "/usr/include/boost/filesystem/path_traits.hpp", 133, __PRETTY_FUNCTION__));
    ((from_end) ? static_cast<void> (0) : __assert_fail ("from_end", "/usr/include/boost/filesystem/path_traits.hpp", 134, __PRETTY_FUNCTION__));
    to.append(from, from_end);
  }

  inline
  void convert(const char* from,
                std::string & to,
                const codecvt_type&)
  {
    ((from) ? static_cast<void> (0) : __assert_fail ("from", "/usr/include/boost/filesystem/path_traits.hpp", 143, __PRETTY_FUNCTION__));
    to += from;
  }



  inline
  void convert(const wchar_t* from, const wchar_t* from_end, std::wstring & to,
    const codecvt_type&)
  {
    ((from) ? static_cast<void> (0) : __assert_fail ("from", "/usr/include/boost/filesystem/path_traits.hpp", 153, __PRETTY_FUNCTION__));
    ((from_end) ? static_cast<void> (0) : __assert_fail ("from_end", "/usr/include/boost/filesystem/path_traits.hpp", 154, __PRETTY_FUNCTION__));
    to.append(from, from_end);
  }

  inline
  void convert(const wchar_t* from,
                std::wstring & to,
                const codecvt_type&)
  {
    ((from) ? static_cast<void> (0) : __assert_fail ("from", "/usr/include/boost/filesystem/path_traits.hpp", 163, __PRETTY_FUNCTION__));
    to += from;
  }




  template <class U> inline
    void dispatch(const std::string& c, U& to, const codecvt_type& cvt)
  {
    if (c.size())
      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
  }
  template <class U> inline
    void dispatch(const std::wstring& c, U& to, const codecvt_type& cvt)
  {
    if (c.size())
      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
  }
  template <class U> inline
    void dispatch(const std::vector<char>& c, U& to, const codecvt_type& cvt)
  {
    if (c.size())
      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
  }
  template <class U> inline
    void dispatch(const std::vector<wchar_t>& c, U& to, const codecvt_type& cvt)
  {
    if (c.size())
      convert(&*c.begin(), &*c.begin() + c.size(), to, cvt);
  }


  template <class Container, class U> inline


    typename boost::disable_if<boost::is_array<Container>, void>::type
      dispatch(const Container & c, U& to, const codecvt_type& cvt)
  {
    if (c.size())
    {
      std::basic_string<typename Container::value_type> s(c.begin(), c.end());
      convert(s.c_str(), s.c_str()+s.size(), to, cvt);
    }
  }


  template <class T, class U> inline
  void dispatch(T * const & c_str, U& to, const codecvt_type& cvt)
  {

    ((c_str) ? static_cast<void> (0) : __assert_fail ("c_str", "/usr/include/boost/filesystem/path_traits.hpp", 214, __PRETTY_FUNCTION__));
    convert(c_str, to, cvt);
  }




 
  void dispatch(const directory_entry & de,



                   std::string & to,

                 const codecvt_type&);


}}}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 234 "/usr/include/boost/filesystem/path_traits.hpp" 2 3 4
# 26 "/usr/include/boost/filesystem/path.hpp" 2 3 4




# 1 "/usr/include/boost/io/detail/quoted_manip.hpp" 1 3 4
# 21 "/usr/include/boost/io/detail/quoted_manip.hpp" 3 4
namespace boost
{
  namespace io
  {
    namespace detail { template <class String, class Char> struct quoted_proxy; }




    template <class Char, class Traits, class Alloc>
      detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
        quoted(const std::basic_string<Char, Traits, Alloc>& s,
               Char escape='\\', Char delim='\"');


    template <class Char, class Traits, class Alloc>
      detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> &, Char>
        quoted(std::basic_string<Char, Traits, Alloc>& s,
               Char escape='\\', Char delim='\"');


    template <class Char>
      detail::quoted_proxy<const Char*, Char>
        quoted(const Char* s, Char escape='\\', Char delim='\"');



    namespace detail
    {

      template <class String, class Char>
      struct quoted_proxy
      {
        String string;
        Char escape;
        Char delim;

        quoted_proxy(String s_, Char escape_, Char delim_)
          : string(s_), escape(escape_), delim(delim_) {}
      private:

        quoted_proxy& operator=(const quoted_proxy&);
      };


      template <class Char, class Traits, class Alloc>
      std::basic_ostream<Char, Traits>&
      basic_string_inserter_imp(std::basic_ostream<Char, Traits>& os,
        std::basic_string<Char, Traits, Alloc> const & string, Char escape, Char delim)
      {
        os << delim;
        typename std::basic_string<Char, Traits, Alloc>::const_iterator
          end_it = string.end();
        for (typename std::basic_string<Char, Traits, Alloc>::const_iterator
          it = string.begin();
          it != end_it;
          ++it )
        {
          if (*it == delim || *it == escape)
            os << escape;
          os << *it;
        }
        os << delim;
        return os;
      }


      template <class Char, class Traits, class Alloc>
      inline
      std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
        const quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>& proxy)
      {
        return basic_string_inserter_imp(os, proxy.string, proxy.escape, proxy.delim);
      }


      template <class Char, class Traits, class Alloc>
      inline
      std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
        const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
      {
        return basic_string_inserter_imp(os, proxy.string, proxy.escape, proxy.delim);
      }


      template <class Char, class Traits>
      std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os,
        const quoted_proxy<const Char*, Char>& proxy)
      {
        os << proxy.delim;
        for (const Char* it = proxy.string;
          *it;
          ++it )
        {
          if (*it == proxy.delim || *it == proxy.escape)
            os << proxy.escape;
          os << *it;
        }
        os << proxy.delim;
        return os;
      }


      template <class Char, class Traits, class Alloc>
      std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is,
        const quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>& proxy)
      {
        proxy.string.clear();
        Char c;
        is >> c;
        if (c != proxy.delim)
        {
          is.unget();
          is >> proxy.string;
          return is;
        }
        {
          boost::io::ios_flags_saver ifs(is);
          is >> std::noskipws;
          for (;;)
          {
            is >> c;
            if (!is.good())
              break;
            if (c == proxy.escape)
            {
              is >> c;
              if (!is.good())
                break;
            }
            else if (c == proxy.delim)
              break;
            proxy.string += c;
          }
        }
        return is;
      }

    }


    template <class Char, class Traits, class Alloc>
    inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
    quoted(const std::basic_string<Char, Traits, Alloc>& s, Char escape, Char delim)
    {
      return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> const &, Char>
        (s, escape, delim);
    }


    template <class Char, class Traits, class Alloc>
    inline detail::quoted_proxy<std::basic_string<Char, Traits, Alloc> &, Char>
    quoted(std::basic_string<Char, Traits, Alloc>& s, Char escape, Char delim)
    {
      return detail::quoted_proxy<std::basic_string<Char, Traits, Alloc>&, Char>
        (s, escape, delim);
    }


    template <class Char>
    inline detail::quoted_proxy<const Char*, Char>
    quoted(const Char* s, Char escape, Char delim)
    {
      return detail::quoted_proxy<const Char*, Char> (s, escape, delim);
    }

  }
}
# 31 "/usr/include/boost/filesystem/path.hpp" 2 3 4

# 1 "/usr/include/boost/functional/hash_fwd.hpp" 1 3 4
# 33 "/usr/include/boost/filesystem/path.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 37 "/usr/include/boost/filesystem/path.hpp" 2 3 4


# 1 "/usr/include/c++/4.8/cassert" 1 3 4
# 41 "/usr/include/c++/4.8/cassert" 3 4
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 40 "/usr/include/boost/filesystem/path.hpp" 2 3 4



# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 44 "/usr/include/boost/filesystem/path.hpp" 2 3 4

namespace boost
{
namespace filesystem
{






  class path
  {
  public:
# 66 "/usr/include/boost/filesystem/path.hpp" 3 4
    typedef char value_type;
    static const value_type preferred_separator = '/';

    typedef std::basic_string<value_type> string_type;
    typedef std::codecvt<wchar_t, char,
                         std::mbstate_t> codecvt_type;
# 130 "/usr/include/boost/filesystem/path.hpp" 3 4
    path(){}

    path(const path& p) : m_pathname(p.m_pathname) {}

    template <class Source>
    path(Source const& source,
      typename boost::enable_if<path_traits::is_pathable<
        typename boost::decay<Source>::type> >::type* =0)
    {
      path_traits::dispatch(source, m_pathname, codecvt());
    }
# 150 "/usr/include/boost/filesystem/path.hpp" 3 4
    path(const value_type* s) : m_pathname(s) {}
    path(const std::basic_string<value_type>& s) : m_pathname(s) {}

    template <class Source>
    path(Source const& source, const codecvt_type& cvt)

    {
      path_traits::dispatch(source, m_pathname, cvt);
    }

    template <class InputIterator>
    path(InputIterator begin, InputIterator end)
    {
      if (begin != end)
      {
        std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
          s(begin, end);
        path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, codecvt());
      }
    }

    template <class InputIterator>
    path(InputIterator begin, InputIterator end, const codecvt_type& cvt)
    {
      if (begin != end)
      {
        std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
          s(begin, end);
        path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
      }
    }



    path& operator=(const path& p)
    {
      m_pathname = p.m_pathname;
      return *this;
    }

    path& operator=(const value_type* ptr)
    {
      m_pathname = ptr;
      return *this;
    }

    template <class Source>
      typename boost::enable_if<path_traits::is_pathable<
        typename boost::decay<Source>::type>, path&>::type
    operator=(Source const& source)
    {
      m_pathname.clear();
      path_traits::dispatch(source, m_pathname, codecvt());
      return *this;
    }

    path& assign(const value_type* ptr, const codecvt_type&)
    {
      m_pathname = ptr;
      return *this;
    }

    template <class Source>
    path& assign(Source const& source, const codecvt_type& cvt)
    {
      m_pathname.clear();
      path_traits::dispatch(source, m_pathname, cvt);
      return *this;
    }

    template <class InputIterator>
    path& assign(InputIterator begin, InputIterator end)
    {
      return assign(begin, end, codecvt());
    }

    template <class InputIterator>
    path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt)
    {
      m_pathname.clear();
      if (begin != end)
      {
        std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
          s(begin, end);
        path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
      }
      return *this;
    }



    path& operator+=(const path& p) {m_pathname += p.m_pathname; return *this;}
    path& operator+=(const string_type& s) {m_pathname += s; return *this;}
    path& operator+=(const value_type* ptr) {m_pathname += ptr; return *this;}
    path& operator+=(value_type c) {m_pathname += c; return *this;}

    template <class Source>
      typename boost::enable_if<path_traits::is_pathable<
        typename boost::decay<Source>::type>, path&>::type
    operator+=(Source const& source)
    {
      return concat(source, codecvt());
    }

    template <class CharT>
      typename boost::enable_if<is_integral<CharT>, path&>::type
    operator+=(CharT c)
    {
      CharT tmp[2];
      tmp[0] = c;
      tmp[1] = 0;
      return concat(tmp, codecvt());
    }

    template <class Source>
    path& concat(Source const& source, const codecvt_type& cvt)
    {
      path_traits::dispatch(source, m_pathname, cvt);
      return *this;
    }

    template <class InputIterator>
    path& concat(InputIterator begin, InputIterator end)
    {
      return concat(begin, end, codecvt());
    }

    template <class InputIterator>
    path& concat(InputIterator begin, InputIterator end, const codecvt_type& cvt)
    {
      if (begin == end)
        return *this;
      std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
        s(begin, end);
      path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
      return *this;
    }






    path& operator/=(const path& p);

    path& operator/=(const value_type* ptr);

    template <class Source>
      typename boost::enable_if<path_traits::is_pathable<
        typename boost::decay<Source>::type>, path&>::type
    operator/=(Source const& source)
    {
      return append(source, codecvt());
    }

    path& append(const value_type* ptr, const codecvt_type&)
    {
      this->operator/=(ptr);
      return *this;
    }

    template <class Source>
    path& append(Source const& source, const codecvt_type& cvt);

    template <class InputIterator>
    path& append(InputIterator begin, InputIterator end)
    {
      return append(begin, end, codecvt());
    }

    template <class InputIterator>
    path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt);



    void clear() { m_pathname.clear(); }
    path& make_preferred()

      { return *this; }



    path& remove_filename();
    path& replace_extension(const path& new_extension = path());
    void swap(path& rhs) { m_pathname.swap(rhs.m_pathname); }
# 357 "/usr/include/boost/filesystem/path.hpp" 3 4
    const string_type& native() const { return m_pathname; }
    const value_type* c_str() const { return m_pathname.c_str(); }

    template <class String>
    String string() const;

    template <class String>
    String string(const codecvt_type& cvt) const;
# 383 "/usr/include/boost/filesystem/path.hpp" 3 4
    const std::string& string() const { return m_pathname; }
    const std::string& string(const codecvt_type&) const { return m_pathname; }

    const std::wstring wstring() const { return wstring(codecvt()); }
    const std::wstring wstring(const codecvt_type& cvt) const
    {
      std::wstring tmp;
      if (!m_pathname.empty())
        path_traits::convert(&*m_pathname.begin(), &*m_pathname.begin()+m_pathname.size(),
          tmp, cvt);
      return tmp;
    }





    template <class String>
    String generic_string() const;

    template <class String>
    String generic_string(const codecvt_type& cvt) const;
# 414 "/usr/include/boost/filesystem/path.hpp" 3 4
    const std::string& generic_string() const { return m_pathname; }
    const std::string& generic_string(const codecvt_type&) const { return m_pathname; }
    const std::wstring generic_wstring() const { return wstring(codecvt()); }
    const std::wstring generic_wstring(const codecvt_type& cvt) const { return wstring(cvt); }





    int compare(const path& p) const ;
    int compare(const std::string& s) const { return compare(path(s)); }
    int compare(const value_type* s) const { return compare(path(s)); }



    path root_path() const;
    path root_name() const;

    path root_directory() const;
    path relative_path() const;
    path parent_path() const;
    path filename() const;
    path stem() const;
    path extension() const;



    bool empty() const { return m_pathname.empty(); }
    bool has_root_path() const { return has_root_directory() || has_root_name(); }
    bool has_root_name() const { return !root_name().empty(); }
    bool has_root_directory() const { return !root_directory().empty(); }
    bool has_relative_path() const { return !relative_path().empty(); }
    bool has_parent_path() const { return !parent_path().empty(); }
    bool has_filename() const { return !m_pathname.empty(); }
    bool has_stem() const { return !stem().empty(); }
    bool has_extension() const { return !extension().empty(); }
    bool is_absolute() const
    {



      return has_root_directory();

    }
    bool is_relative() const { return !is_absolute(); }



    class iterator;
    typedef iterator const_iterator;

    iterator begin() const;
    iterator end() const;



    static std::locale imbue(const std::locale& loc);
    static const codecvt_type& codecvt();
# 481 "/usr/include/boost/filesystem/path.hpp" 3 4
    path& normalize() { return m_normalize(); }
    path& remove_leaf() { return remove_filename(); }
    path leaf() const { return filename(); }
    path branch_path() const { return parent_path(); }
    bool has_leaf() const { return !m_pathname.empty(); }
    bool has_branch_path() const { return !parent_path().empty(); }
    bool is_complete() const { return is_absolute(); }





    const std::string file_string() const { return string(); }
    const std::string directory_string() const { return string(); }
    const std::string native_file_string() const { return string(); }
    const std::string native_directory_string() const { return string(); }
    const string_type external_file_string() const { return native(); }
    const string_type external_directory_string() const { return native(); }
# 515 "/usr/include/boost/filesystem/path.hpp" 3 4
  private:
# 528 "/usr/include/boost/filesystem/path.hpp" 3 4
    string_type m_pathname;





    string_type::size_type m_append_separator_if_needed();



    void m_erase_redundant_separator(string_type::size_type sep_pos);
    string_type::size_type m_parent_path_end() const;

    path& m_normalize();



    friend class iterator;
    friend bool operator<(const path& lhs, const path& rhs);


    static void m_path_iterator_increment(path::iterator & it);
    static void m_path_iterator_decrement(path::iterator & it);

  };

  namespace detail
  {
   
      int lex_compare(path::iterator first1, path::iterator last1,
        path::iterator first2, path::iterator last2);
  }


  typedef path wpath;






  class path::iterator
    : public boost::iterator_facade<
      path::iterator,
      path const,
      boost::bidirectional_traversal_tag >
  {
  private:
    friend class boost::iterator_core_access;
    friend class boost::filesystem::path;
    friend void m_path_iterator_increment(path::iterator & it);
    friend void m_path_iterator_decrement(path::iterator & it);

    const path& dereference() const { return m_element; }

    bool equal(const iterator & rhs) const
    {
      return m_path_ptr == rhs.m_path_ptr && m_pos == rhs.m_pos;
    }



    void increment() { m_path_iterator_increment(*this); }
    void decrement() { m_path_iterator_decrement(*this); }

    path m_element;
    const path* m_path_ptr;
    string_type::size_type m_pos;





  };
# 611 "/usr/include/boost/filesystem/path.hpp" 3 4
  inline bool lexicographical_compare(path::iterator first1, path::iterator last1,
    path::iterator first2, path::iterator last2)
    { return detail::lex_compare(first1, last1, first2, last2) < 0; }

  inline bool operator==(const path& lhs, const path& rhs) {return lhs.compare(rhs) == 0;}
  inline bool operator==(const path& lhs, const path::string_type& rhs) {return lhs.compare(rhs) == 0;}
  inline bool operator==(const path::string_type& lhs, const path& rhs) {return rhs.compare(lhs) == 0;}
  inline bool operator==(const path& lhs, const path::value_type* rhs) {return lhs.compare(rhs) == 0;}
  inline bool operator==(const path::value_type* lhs, const path& rhs) {return rhs.compare(lhs) == 0;}

  inline bool operator!=(const path& lhs, const path& rhs) {return lhs.compare(rhs) != 0;}
  inline bool operator!=(const path& lhs, const path::string_type& rhs) {return lhs.compare(rhs) != 0;}
  inline bool operator!=(const path::string_type& lhs, const path& rhs) {return rhs.compare(lhs) != 0;}
  inline bool operator!=(const path& lhs, const path::value_type* rhs) {return lhs.compare(rhs) != 0;}
  inline bool operator!=(const path::value_type* lhs, const path& rhs) {return rhs.compare(lhs) != 0;}



  inline bool operator<(const path& lhs, const path& rhs) {return lhs.compare(rhs) < 0;}
  inline bool operator<=(const path& lhs, const path& rhs) {return !(rhs < lhs);}
  inline bool operator> (const path& lhs, const path& rhs) {return rhs < lhs;}
  inline bool operator>=(const path& lhs, const path& rhs) {return !(lhs < rhs);}

  inline std::size_t hash_value(const path& x)
  {






    return hash_range(x.native().begin(), x.native().end());

  }

  inline void swap(path& lhs, path& rhs) { lhs.swap(rhs); }

  inline path operator/(const path& lhs, const path& rhs) { return path(lhs) /= rhs; }





  template <class Char, class Traits>
  inline std::basic_ostream<Char, Traits>&
  operator<<(std::basic_ostream<Char, Traits>& os, const path& p)
  {
    return os
      << boost::io::quoted(p.template string<std::basic_string<Char> >(), static_cast<Char>('&'));
  }

  template <class Char, class Traits>
  inline std::basic_istream<Char, Traits>&
  operator>>(std::basic_istream<Char, Traits>& is, path& p)
  {
    std::basic_string<Char> str;
    is >> boost::io::quoted(str, static_cast<Char>('&'));
    p = str;
    return is;
  }






  bool portable_posix_name(const std::string & name);
  bool windows_name(const std::string & name);
  bool portable_name(const std::string & name);
  bool portable_directory_name(const std::string & name);
  bool portable_file_name(const std::string & name);
  bool native(const std::string & name);





  template <class InputIterator>
  path& path::append(InputIterator begin, InputIterator end, const codecvt_type& cvt)
  {
    if (begin == end)
      return *this;
    string_type::size_type sep_pos(m_append_separator_if_needed());
    std::basic_string<typename std::iterator_traits<InputIterator>::value_type>
      s(begin, end);
    path_traits::convert(s.c_str(), s.c_str()+s.size(), m_pathname, cvt);
    if (sep_pos)
      m_erase_redundant_separator(sep_pos);
    return *this;
  }

  template <class Source>
  path& path::append(Source const& source, const codecvt_type& cvt)
  {
    if (path_traits::empty(source))
      return *this;
    string_type::size_type sep_pos(m_append_separator_if_needed());
    path_traits::dispatch(source, m_pathname, cvt);
    if (sep_pos)
      m_erase_redundant_separator(sep_pos);
    return *this;
  }





  template <> inline
  std::string path::string<std::string>() const
    { return string(); }

  template <> inline
  std::wstring path::string<std::wstring>() const
    { return wstring(); }

  template <> inline
  std::string path::string<std::string>(const codecvt_type& cvt) const
    { return string(cvt); }

  template <> inline
  std::wstring path::string<std::wstring>(const codecvt_type& cvt) const
    { return wstring(cvt); }

  template <> inline
  std::string path::generic_string<std::string>() const
    { return generic_string(); }

  template <> inline
  std::wstring path::generic_string<std::wstring>() const
    { return generic_wstring(); }

  template <> inline
  std::string path::generic_string<std::string>(const codecvt_type& cvt) const
    { return generic_string(cvt); }

  template <> inline
  std::wstring path::generic_string<std::wstring>(const codecvt_type& cvt) const
    { return generic_wstring(cvt); }


}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 757 "/usr/include/boost/filesystem/path.hpp" 2 3 4
# 17 "/usr/include/boost/filesystem.hpp" 2 3 4
# 1 "/usr/include/boost/filesystem/operations.hpp" 1 3 4
# 28 "/usr/include/boost/filesystem/operations.hpp" 3 4
# 1 "/usr/include/boost/detail/bitmask.hpp" 1 3 4
# 18 "/usr/include/boost/detail/bitmask.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 19 "/usr/include/boost/detail/bitmask.hpp" 2 3 4
# 29 "/usr/include/boost/filesystem/operations.hpp" 2 3 4






# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 36 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 37 "/usr/include/boost/filesystem/operations.hpp" 2 3 4



# 1 "/usr/include/c++/4.8/ctime" 1 3 4
# 39 "/usr/include/c++/4.8/ctime" 3 4
       
# 40 "/usr/include/c++/4.8/ctime" 3
# 41 "/usr/include/boost/filesystem/operations.hpp" 2 3 4

# 1 "/usr/include/c++/4.8/stack" 1 3 4
# 58 "/usr/include/c++/4.8/stack" 3 4
       
# 59 "/usr/include/c++/4.8/stack" 3


# 1 "/usr/include/c++/4.8/bits/stl_stack.h" 1 3
# 62 "/usr/include/c++/4.8/bits/stl_stack.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 95 "/usr/include/c++/4.8/bits/stl_stack.h" 3
  template<typename _Tp, typename _Sequence = deque<_Tp> >
    class stack
    {

      typedef typename _Sequence::value_type _Sequence_value_type;
     
     
     

      template<typename _Tp1, typename _Seq1>
        friend bool
        operator==(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);

      template<typename _Tp1, typename _Seq1>
        friend bool
        operator<(const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);

    public:
      typedef typename _Sequence::value_type value_type;
      typedef typename _Sequence::reference reference;
      typedef typename _Sequence::const_reference const_reference;
      typedef typename _Sequence::size_type size_type;
      typedef _Sequence container_type;

    protected:

      _Sequence c;

    public:





      explicit
      stack(const _Sequence& __c = _Sequence())
      : c(__c) { }
# 145 "/usr/include/c++/4.8/bits/stl_stack.h" 3
      bool
      empty() const
      { return c.empty(); }


      size_type
      size() const
      { return c.size(); }





      reference
      top()
      {
 ;
 return c.back();
      }





      const_reference
      top() const
      {
 ;
 return c.back();
      }
# 185 "/usr/include/c++/4.8/bits/stl_stack.h" 3
      void
      push(const value_type& __x)
      { c.push_back(__x); }
# 211 "/usr/include/c++/4.8/bits/stl_stack.h" 3
      void
      pop()
      {
 ;
 c.pop_back();
      }
# 227 "/usr/include/c++/4.8/bits/stl_stack.h" 3
    };
# 241 "/usr/include/c++/4.8/bits/stl_stack.h" 3
  template<typename _Tp, typename _Seq>
    inline bool
    operator==(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __x.c == __y.c; }
# 259 "/usr/include/c++/4.8/bits/stl_stack.h" 3
  template<typename _Tp, typename _Seq>
    inline bool
    operator<(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __x.c < __y.c; }


  template<typename _Tp, typename _Seq>
    inline bool
    operator!=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Seq>
    inline bool
    operator>(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Seq>
    inline bool
    operator<=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Seq>
    inline bool
    operator>=(const stack<_Tp, _Seq>& __x, const stack<_Tp, _Seq>& __y)
    { return !(__x < __y); }
# 300 "/usr/include/c++/4.8/bits/stl_stack.h" 3

}
# 62 "/usr/include/c++/4.8/stack" 2 3
# 43 "/usr/include/boost/filesystem/operations.hpp" 2 3 4





# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 49 "/usr/include/boost/filesystem/operations.hpp" 2 3 4



namespace boost
{
  namespace filesystem
  {





  enum file_type
  {
    status_error,

    status_unknown = status_error,

    file_not_found,
    regular_file,
    directory_file,

    symlink_file,
    block_file,
    character_file,
    fifo_file,
    socket_file,
    reparse_file,
    type_unknown,


    _detail_directory_symlink
  };





  enum perms
  {
    no_perms = 0,






    owner_read = 0400,
    owner_write = 0200,
    owner_exe = 0100,
    owner_all = 0700,

    group_read = 040,
    group_write = 020,
    group_exe = 010,
    group_all = 070,

    others_read = 04,
    others_write = 02,
    others_exe = 01,
    others_all = 07,

    all_all = owner_all|group_all|others_all,



    set_uid_on_exe = 04000,
    set_gid_on_exe = 02000,
    sticky_bit = 01000,






    perms_mask = all_all|set_uid_on_exe|set_gid_on_exe|sticky_bit,

    perms_not_known = 0xFFFF,



    add_perms = 0x1000,
    remove_perms = 0x2000,




    symlink_perms = 0x4000
  };

  inline perms operator| (perms x , perms y ) { return static_cast<perms>( static_cast<boost::int_least32_t>(x) | static_cast<boost::int_least32_t>(y)); } inline perms operator& (perms x , perms y ) { return static_cast<perms>( static_cast<boost::int_least32_t>(x) & static_cast<boost::int_least32_t>(y)); } inline perms operator^ (perms x , perms y ) { return static_cast<perms>( static_cast<boost::int_least32_t>(x) ^ static_cast<boost::int_least32_t>(y)); } inline perms operator~ (perms x ) { return static_cast<perms>(~static_cast<boost::int_least32_t>(x)); } inline perms & operator&=(perms & x , perms y) { x = x & y ; return x ; } inline perms & operator|=(perms & x , perms y) { x = x | y ; return x ; } inline perms & operator^=(perms & x , perms y) { x = x ^ y ; return x ; }





  class file_status
  {
  public:
             file_status() : m_value(status_error), m_perms(perms_not_known) {}
    explicit file_status(file_type v, perms prms = perms_not_known)
                                      : m_value(v), m_perms(prms) {}


    file_type type() const { return m_value; }
    perms permissions() const { return m_perms; }


    void type(file_type v) { m_value = v; }
    void permissions(perms prms) { m_perms = prms; }

    bool operator==(const file_status& rhs) const { return type() == rhs.type() &&
                                                    permissions() == rhs.permissions(); }
    bool operator!=(const file_status& rhs) const { return !(*this == rhs); }

  private:
    file_type m_value;
    enum perms m_perms;
  };

  inline bool type_present(file_status f) { return f.type() != status_error; }
  inline bool permissions_present(file_status f)
                                          {return f.permissions() != perms_not_known;}
  inline bool status_known(file_status f) { return type_present(f) && permissions_present(f); }
  inline bool exists(file_status f) { return f.type() != status_error
                                                && f.type() != file_not_found; }
  inline bool is_regular_file(file_status f){ return f.type() == regular_file; }
  inline bool is_directory(file_status f) { return f.type() == directory_file; }
  inline bool is_symlink(file_status f) { return f.type() == symlink_file; }
  inline bool is_other(file_status f) { return exists(f) && !is_regular_file(f)
                                                && !is_directory(f) && !is_symlink(f); }


  inline bool is_regular(file_status f) { return f.type() == regular_file; }


  struct space_info
  {

    boost::uintmax_t capacity;
    boost::uintmax_t free;
    boost::uintmax_t available;
  };

  struct copy_option { typedef int underlying_type; copy_option() {} explicit copy_option(underlying_type v) : v_(v) {} underlying_type get_underlying_value_() const { return v_; } private: underlying_type v_; typedef copy_option self_type; public: enum enum_type
    {none, fail_if_exists = none, overwrite_if_exists};
  enum_type get_native_value_() const { return enum_type(v_); } operator enum_type() const { return get_native_value_(); } friend bool operator ==(self_type lhs, self_type rhs) { return enum_type(lhs.v_)==enum_type(rhs.v_); } friend bool operator ==(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)==rhs; } friend bool operator ==(enum_type lhs, self_type rhs) { return lhs==enum_type(rhs.v_); } friend bool operator !=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)!=enum_type(rhs.v_); } friend bool operator !=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)!=rhs; } friend bool operator !=(enum_type lhs, self_type rhs) { return lhs!=enum_type(rhs.v_); } friend bool operator <(self_type lhs, self_type rhs) { return enum_type(lhs.v_)<enum_type(rhs.v_); } friend bool operator <(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)<rhs; } friend bool operator <(enum_type lhs, self_type rhs) { return lhs<enum_type(rhs.v_); } friend bool operator <=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)<=enum_type(rhs.v_); } friend bool operator <=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)<=rhs; } friend bool operator <=(enum_type lhs, self_type rhs) { return lhs<=enum_type(rhs.v_); } friend bool operator >(self_type lhs, self_type rhs) { return enum_type(lhs.v_)>enum_type(rhs.v_); } friend bool operator >(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)>rhs; } friend bool operator >(enum_type lhs, self_type rhs) { return lhs>enum_type(rhs.v_); } friend bool operator >=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)>=enum_type(rhs.v_); } friend bool operator >=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)>=rhs; } friend bool operator >=(enum_type lhs, self_type rhs) { return lhs>=enum_type(rhs.v_); } };





  namespace detail
  {
   
    file_status status(const path&p, system::error_code* ec=0);
   
    file_status symlink_status(const path& p, system::error_code* ec=0);
   
    bool is_empty(const path& p, system::error_code* ec=0);
   
    path initial_path(system::error_code* ec=0);
   
    path canonical(const path& p, const path& base, system::error_code* ec=0);
   
    void copy(const path& from, const path& to, system::error_code* ec=0);
   
    void copy_directory(const path& from, const path& to, system::error_code* ec=0);
   
    void copy_file(const path& from, const path& to,
                    copy_option::enum_type option,
                    system::error_code* ec=0);
   
    void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code* ec=0);
   
    bool create_directories(const path& p, system::error_code* ec=0);
   
    bool create_directory(const path& p, system::error_code* ec=0);
   
    void create_directory_symlink(const path& to, const path& from,
                                  system::error_code* ec=0);
   
    void create_hard_link(const path& to, const path& from, system::error_code* ec=0);
   
    void create_symlink(const path& to, const path& from, system::error_code* ec=0);
   
    path current_path(system::error_code* ec=0);
   
    void current_path(const path& p, system::error_code* ec=0);
   
    bool equivalent(const path& p1, const path& p2, system::error_code* ec=0);
   
    boost::uintmax_t file_size(const path& p, system::error_code* ec=0);
   
    boost::uintmax_t hard_link_count(const path& p, system::error_code* ec=0);
   
    std::time_t last_write_time(const path& p, system::error_code* ec=0);
   
    void last_write_time(const path& p, const std::time_t new_time,
                         system::error_code* ec=0);
   
    void permissions(const path& p, perms prms, system::error_code* ec=0);
   
    path read_symlink(const path& p, system::error_code* ec=0);
   

    bool remove(const path& p, system::error_code* ec=0);
   
    boost::uintmax_t remove_all(const path& p, system::error_code* ec=0);
   
    void rename(const path& old_p, const path& new_p, system::error_code* ec=0);
   
    void resize_file(const path& p, uintmax_t size, system::error_code* ec=0);
   
    space_info space(const path& p, system::error_code* ec=0);
   
    path system_complete(const path& p, system::error_code* ec=0);
   
    path temp_directory_path(system::error_code* ec=0);
   
    path unique_path(const path& p, system::error_code* ec=0);
  }







  inline
  file_status status(const path& p) {return detail::status(p);}
  inline
  file_status status(const path& p, system::error_code& ec)
                                       {return detail::status(p, &ec);}
  inline
  file_status symlink_status(const path& p) {return detail::symlink_status(p);}
  inline
  file_status symlink_status(const path& p, system::error_code& ec)
                                       {return detail::symlink_status(p, &ec);}
  inline
  bool exists(const path& p) {return exists(detail::status(p));}
  inline
  bool exists(const path& p, system::error_code& ec)
                                       {return exists(detail::status(p, &ec));}
  inline
  bool is_directory(const path& p) {return is_directory(detail::status(p));}
  inline
  bool is_directory(const path& p, system::error_code& ec)
                                       {return is_directory(detail::status(p, &ec));}
  inline
  bool is_regular_file(const path& p) {return is_regular_file(detail::status(p));}
  inline
  bool is_regular_file(const path& p, system::error_code& ec)
                                       {return is_regular_file(detail::status(p, &ec));}
  inline
  bool is_other(const path& p) {return is_other(detail::status(p));}
  inline
  bool is_other(const path& p, system::error_code& ec)
                                       {return is_other(detail::status(p, &ec));}
  inline
  bool is_symlink(const path& p) {return is_symlink(detail::symlink_status(p));}
  inline
  bool is_symlink(const path& p, system::error_code& ec)
                                       {return is_symlink(detail::symlink_status(p, &ec));}

  inline
  bool is_regular(const path& p) {return is_regular(detail::status(p));}
  inline
  bool is_regular(const path& p, system::error_code& ec)
                                       {return is_regular(detail::status(p, &ec));}


  inline
  bool is_empty(const path& p) {return detail::is_empty(p);}
  inline
  bool is_empty(const path& p, system::error_code& ec)
                                       {return detail::is_empty(p, &ec);}
# 335 "/usr/include/boost/filesystem/operations.hpp" 3 4
  path current_path();
  path initial_path();

 
  path absolute(const path& p, const path& base=current_path());


  inline
  path canonical(const path& p, const path& base=current_path())
                                       {return detail::canonical(p, base);}
  inline
  path canonical(const path& p, system::error_code& ec)
                                       {return detail::canonical(p, current_path(), &ec);}
  inline
  path canonical(const path& p, const path& base, system::error_code& ec)
                                       {return detail::canonical(p, base, &ec);}


  inline
  path complete(const path& p)
  {
    return absolute(p, initial_path());
  }

  inline
  path complete(const path& p, const path& base)
  {
    return absolute(p, base);
  }


  inline
  void copy(const path& from, const path& to) {detail::copy(from, to);}

  inline
  void copy(const path& from, const path& to, system::error_code& ec)
                                       {detail::copy(from, to, &ec);}
  inline
  void copy_directory(const path& from, const path& to)
                                       {detail::copy_directory(from, to);}
  inline
  void copy_directory(const path& from, const path& to, system::error_code& ec)
                                       {detail::copy_directory(from, to, &ec);}
  inline
  void copy_file(const path& from, const path& to,
                 copy_option::enum_type option)
                                       {detail::copy_file(from, to, option);}
  inline
  void copy_file(const path& from, const path& to)
                                       {detail::copy_file(from, to, copy_option::fail_if_exists);}
  inline
  void copy_file(const path& from, const path& to,
                 copy_option::enum_type option, system::error_code& ec)
                                       {detail::copy_file(from, to, option, &ec);}
  inline
  void copy_file(const path& from, const path& to, system::error_code& ec)
                                       {detail::copy_file(from, to, copy_option::fail_if_exists, &ec);}
  inline
  void copy_symlink(const path& existing_symlink, const path& new_symlink) {detail::copy_symlink(existing_symlink, new_symlink);}

  inline
  void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec)
                                       {detail::copy_symlink(existing_symlink, new_symlink, &ec);}
  inline
  bool create_directories(const path& p) {return detail::create_directories(p);}

  inline
  bool create_directories(const path& p, system::error_code& ec)
                                       {return detail::create_directories(p, &ec);}
  inline
  bool create_directory(const path& p) {return detail::create_directory(p);}

  inline
  bool create_directory(const path& p, system::error_code& ec)
                                       {return detail::create_directory(p, &ec);}
  inline
  void create_directory_symlink(const path& to, const path& from)
                                       {detail::create_directory_symlink(to, from);}
  inline
  void create_directory_symlink(const path& to, const path& from, system::error_code& ec)
                                       {detail::create_directory_symlink(to, from, &ec);}
  inline
  void create_hard_link(const path& to, const path& new_hard_link) {detail::create_hard_link(to, new_hard_link);}

  inline
  void create_hard_link(const path& to, const path& new_hard_link, system::error_code& ec)
                                       {detail::create_hard_link(to, new_hard_link, &ec);}
  inline
  void create_symlink(const path& to, const path& new_symlink) {detail::create_symlink(to, new_symlink);}

  inline
  void create_symlink(const path& to, const path& new_symlink, system::error_code& ec)
                                       {detail::create_symlink(to, new_symlink, &ec);}
  inline
  path current_path() {return detail::current_path();}

  inline
  path current_path(system::error_code& ec) {return detail::current_path(&ec);}

  inline
  void current_path(const path& p) {detail::current_path(p);}

  inline
  void current_path(const path& p, system::error_code& ec) {detail::current_path(p, &ec);}

  inline
  bool equivalent(const path& p1, const path& p2) {return detail::equivalent(p1, p2);}

  inline
  bool equivalent(const path& p1, const path& p2, system::error_code& ec)
                                       {return detail::equivalent(p1, p2, &ec);}
  inline
  boost::uintmax_t file_size(const path& p) {return detail::file_size(p);}

  inline
  boost::uintmax_t file_size(const path& p, system::error_code& ec)
                                       {return detail::file_size(p, &ec);}
  inline
  boost::uintmax_t hard_link_count(const path& p) {return detail::hard_link_count(p);}

  inline
  boost::uintmax_t hard_link_count(const path& p, system::error_code& ec)
                                       {return detail::hard_link_count(p, &ec);}
  inline
  path initial_path() {return detail::initial_path();}

  inline
  path initial_path(system::error_code& ec) {return detail::initial_path(&ec);}

  template <class Path>
  path initial_path() {return initial_path();}
  template <class Path>
  path initial_path(system::error_code& ec) {return detail::initial_path(&ec);}

  inline
  std::time_t last_write_time(const path& p) {return detail::last_write_time(p);}

  inline
  std::time_t last_write_time(const path& p, system::error_code& ec)
                                       {return detail::last_write_time(p, &ec);}
  inline
  void last_write_time(const path& p, const std::time_t new_time)
                                       {detail::last_write_time(p, new_time);}
  inline
  void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec)
                                       {detail::last_write_time(p, new_time, &ec);}
  inline
  void permissions(const path& p, perms prms)
                                       {detail::permissions(p, prms);}
  inline
  void permissions(const path& p, perms prms, system::error_code& ec)
                                       {detail::permissions(p, prms, &ec);}

  inline
  path read_symlink(const path& p) {return detail::read_symlink(p);}

  inline
  path read_symlink(const path& p, system::error_code& ec)
                                       {return detail::read_symlink(p, &ec);}
  inline

  bool remove(const path& p) {return detail::remove(p);}

  inline
  bool remove(const path& p, system::error_code& ec) {return detail::remove(p, &ec);}

  inline
  boost::uintmax_t remove_all(const path& p) {return detail::remove_all(p);}

  inline
  boost::uintmax_t remove_all(const path& p, system::error_code& ec)
                                       {return detail::remove_all(p, &ec);}
  inline
  void rename(const path& old_p, const path& new_p) {detail::rename(old_p, new_p);}

  inline
  void rename(const path& old_p, const path& new_p, system::error_code& ec)
                                       {detail::rename(old_p, new_p, &ec);}
  inline
  void resize_file(const path& p, uintmax_t size) {detail::resize_file(p, size);}

  inline
  void resize_file(const path& p, uintmax_t size, system::error_code& ec)
                                       {detail::resize_file(p, size, &ec);}
  inline
  space_info space(const path& p) {return detail::space(p);}

  inline
  space_info space(const path& p, system::error_code& ec) {return detail::space(p, &ec);}


  inline bool symbolic_link_exists(const path& p)
                                       { return is_symlink(symlink_status(p)); }


  inline
  path system_complete(const path& p) {return detail::system_complete(p);}

  inline
  path system_complete(const path& p, system::error_code& ec)
                                       {return detail::system_complete(p, &ec);}
  inline
  path temp_directory_path() {return detail::temp_directory_path();}

  inline
  path temp_directory_path(system::error_code& ec)
                                       {return detail::temp_directory_path(&ec);}
  inline
  path unique_path(const path& p="%%%%-%%%%-%%%%-%%%%")
                                       { return detail::unique_path(p); }
  inline
  path unique_path(const path& p, system::error_code& ec)
                                       { return detail::unique_path(p, &ec); }
# 559 "/usr/include/boost/filesystem/operations.hpp" 3 4
class directory_entry
{
public:



  directory_entry() {}
  explicit directory_entry(const boost::filesystem::path& p,
    file_status st = file_status(), file_status symlink_st=file_status())
    : m_path(p), m_status(st), m_symlink_status(symlink_st)
    {}

  void assign(const boost::filesystem::path& p,
    file_status st = file_status(), file_status symlink_st = file_status())
    { m_path = p; m_status = st; m_symlink_status = symlink_st; }

  void replace_filename(const boost::filesystem::path& p,
    file_status st = file_status(), file_status symlink_st = file_status())
  {
    m_path.remove_filename();
    m_path /= p;
    m_status = st;
    m_symlink_status = symlink_st;
  }


  void replace_leaf(const boost::filesystem::path& p,
    file_status st, file_status symlink_st)
      { replace_filename(p, st, symlink_st); }


  const boost::filesystem::path& path() const {return m_path;}
  file_status status() const {return m_get_status();}
  file_status status(system::error_code& ec) const {return m_get_status(&ec);}
  file_status symlink_status() const {return m_get_symlink_status();}
  file_status symlink_status(system::error_code& ec) const {return m_get_symlink_status(&ec);}

  bool operator==(const directory_entry& rhs) {return m_path == rhs.m_path;}
  bool operator!=(const directory_entry& rhs) {return m_path != rhs.m_path;}
  bool operator< (const directory_entry& rhs) {return m_path < rhs.m_path;}
  bool operator<=(const directory_entry& rhs) {return m_path <= rhs.m_path;}
  bool operator> (const directory_entry& rhs) {return m_path > rhs.m_path;}
  bool operator>=(const directory_entry& rhs) {return m_path >= rhs.m_path;}

private:
  boost::filesystem::path m_path;
  mutable file_status m_status;
  mutable file_status m_symlink_status;

  file_status m_get_status(system::error_code* ec=0) const;
  file_status m_get_symlink_status(system::error_code* ec=0) const;
};







class directory_iterator;

namespace detail
{
 
    system::error_code dir_itr_close(
    void *& handle

    , void *& buffer

  );

  struct dir_itr_imp
  {
    directory_entry dir_entry;
    void* handle;


    void* buffer;


    dir_itr_imp() : handle(0)

      , buffer(0)

    {}

    ~dir_itr_imp()
    {
      dir_itr_close(handle

         , buffer

    );
    }
  };


  void directory_iterator_construct(directory_iterator& it,
    const path& p, system::error_code* ec);
  void directory_iterator_increment(directory_iterator& it,
    system::error_code* ec);

}







  class directory_iterator
    : public boost::iterator_facade< directory_iterator,
                                     directory_entry,
                                     boost::single_pass_traversal_tag >
  {
  public:

    directory_iterator(){}



    explicit directory_iterator(const path& p)
        : m_imp(new detail::dir_itr_imp)
          { detail::directory_iterator_construct(*this, p, 0); }

    directory_iterator(const path& p, system::error_code& ec)
        : m_imp(new detail::dir_itr_imp)
          { detail::directory_iterator_construct(*this, p, &ec); }

   ~directory_iterator() {}

    directory_iterator& increment(system::error_code& ec)
    {
      detail::directory_iterator_increment(*this, &ec);
      return *this;
    }

  private:
    friend struct detail::dir_itr_imp;
    friend void detail::directory_iterator_construct(directory_iterator& it,
      const path& p, system::error_code* ec);
    friend void detail::directory_iterator_increment(directory_iterator& it,
      system::error_code* ec);



    boost::shared_ptr< detail::dir_itr_imp > m_imp;

    friend class boost::iterator_core_access;

    boost::iterator_facade<
      directory_iterator,
      directory_entry,
      boost::single_pass_traversal_tag >::reference dereference() const
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "attempt to dereference end iterator", __PRETTY_FUNCTION__, "/usr/include/boost/filesystem/operations.hpp", 714));
      return m_imp->dir_entry;
    }

    void increment() { detail::directory_iterator_increment(*this, 0); }

    bool equal(const directory_iterator& rhs) const
      { return m_imp == rhs.m_imp; }
  };







  struct symlink_option { typedef int underlying_type; symlink_option() {} explicit symlink_option(underlying_type v) : v_(v) {} underlying_type get_underlying_value_() const { return v_; } private: underlying_type v_; typedef symlink_option self_type; public: enum enum_type
  {
    none,
    no_recurse = none,
    recurse,
    _detail_no_push = recurse << 1
  };
  enum_type get_native_value_() const { return enum_type(v_); } operator enum_type() const { return get_native_value_(); } friend bool operator ==(self_type lhs, self_type rhs) { return enum_type(lhs.v_)==enum_type(rhs.v_); } friend bool operator ==(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)==rhs; } friend bool operator ==(enum_type lhs, self_type rhs) { return lhs==enum_type(rhs.v_); } friend bool operator !=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)!=enum_type(rhs.v_); } friend bool operator !=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)!=rhs; } friend bool operator !=(enum_type lhs, self_type rhs) { return lhs!=enum_type(rhs.v_); } friend bool operator <(self_type lhs, self_type rhs) { return enum_type(lhs.v_)<enum_type(rhs.v_); } friend bool operator <(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)<rhs; } friend bool operator <(enum_type lhs, self_type rhs) { return lhs<enum_type(rhs.v_); } friend bool operator <=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)<=enum_type(rhs.v_); } friend bool operator <=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)<=rhs; } friend bool operator <=(enum_type lhs, self_type rhs) { return lhs<=enum_type(rhs.v_); } friend bool operator >(self_type lhs, self_type rhs) { return enum_type(lhs.v_)>enum_type(rhs.v_); } friend bool operator >(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)>rhs; } friend bool operator >(enum_type lhs, self_type rhs) { return lhs>enum_type(rhs.v_); } friend bool operator >=(self_type lhs, self_type rhs) { return enum_type(lhs.v_)>=enum_type(rhs.v_); } friend bool operator >=(self_type lhs, enum_type rhs) { return enum_type(lhs.v_)>=rhs; } friend bool operator >=(enum_type lhs, self_type rhs) { return lhs>=enum_type(rhs.v_); } };

  inline symlink_option::enum_type operator| (symlink_option::enum_type x , symlink_option::enum_type y ) { return static_cast<symlink_option::enum_type>( static_cast<boost::int_least32_t>(x) | static_cast<boost::int_least32_t>(y)); } inline symlink_option::enum_type operator& (symlink_option::enum_type x , symlink_option::enum_type y ) { return static_cast<symlink_option::enum_type>( static_cast<boost::int_least32_t>(x) & static_cast<boost::int_least32_t>(y)); } inline symlink_option::enum_type operator^ (symlink_option::enum_type x , symlink_option::enum_type y ) { return static_cast<symlink_option::enum_type>( static_cast<boost::int_least32_t>(x) ^ static_cast<boost::int_least32_t>(y)); } inline symlink_option::enum_type operator~ (symlink_option::enum_type x ) { return static_cast<symlink_option::enum_type>(~static_cast<boost::int_least32_t>(x)); } inline symlink_option::enum_type & operator&=(symlink_option::enum_type & x , symlink_option::enum_type y) { x = x & y ; return x ; } inline symlink_option::enum_type & operator|=(symlink_option::enum_type & x , symlink_option::enum_type y) { x = x | y ; return x ; } inline symlink_option::enum_type & operator^=(symlink_option::enum_type & x , symlink_option::enum_type y) { x = x ^ y ; return x ; }

  namespace detail
  {
    struct recur_dir_itr_imp
    {
      typedef directory_iterator element_type;
      std::stack< element_type, std::vector< element_type > > m_stack;
      int m_level;
      symlink_option::enum_type m_options;

      recur_dir_itr_imp() : m_level(0), m_options(symlink_option::none) {}

      void increment(system::error_code* ec);

      void pop();

    };





    inline
    void recur_dir_itr_imp::increment(system::error_code* ec)

    {
      if ((m_options & symlink_option::_detail_no_push) == symlink_option::_detail_no_push)
        m_options &= ~symlink_option::_detail_no_push;

      else
      {







        bool or_pred = (m_options & symlink_option::recurse) == symlink_option::recurse
                       || (ec == 0 ? !is_symlink(m_stack.top()->symlink_status())
                                   : !is_symlink(m_stack.top()->symlink_status(*ec)));
        if (ec != 0 && *ec)
          return;
        bool and_pred = or_pred && (ec == 0 ? is_directory(m_stack.top()->status())
                                            : is_directory(m_stack.top()->status(*ec)));
        if (ec != 0 && *ec)
          return;

        if (and_pred)
        {
          if (ec == 0)
            m_stack.push(directory_iterator(m_stack.top()->path()));
          else
          {
            m_stack.push(directory_iterator(m_stack.top()->path(), *ec));
            if (*ec)
              return;
          }
          if (m_stack.top() != directory_iterator())
          {
            ++m_level;
            return;
          }
          m_stack.pop();
        }
      }

      while (!m_stack.empty() && ++m_stack.top() == directory_iterator())
      {
        m_stack.pop();
        --m_level;
      }
    }

    inline
    void recur_dir_itr_imp::pop()
    {
      ((m_level > 0) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_level > 0", "pop() on recursive_directory_iterator with level < 1", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 817 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 818
# 817 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                               ;

      do
      {
        m_stack.pop();
        --m_level;
      }
      while (!m_stack.empty() && ++m_stack.top() == directory_iterator());
    }
  }







  class recursive_directory_iterator
    : public boost::iterator_facade<
        recursive_directory_iterator,
        directory_entry,
        boost::single_pass_traversal_tag >
  {
  public:

    recursive_directory_iterator(){}

    explicit recursive_directory_iterator(const path& dir_path,
      symlink_option::enum_type opt = symlink_option::none)
      : m_imp(new detail::recur_dir_itr_imp)
    {
      m_imp->m_options = opt;
      m_imp->m_stack.push(directory_iterator(dir_path));
      if (m_imp->m_stack.top() == directory_iterator())
        { m_imp.reset (); }
    }

    recursive_directory_iterator(const path& dir_path,
      symlink_option::enum_type opt,
      system::error_code & ec)
    : m_imp(new detail::recur_dir_itr_imp)
    {
      m_imp->m_options = opt;
      m_imp->m_stack.push(directory_iterator(dir_path, ec));
      if (m_imp->m_stack.top() == directory_iterator())
        { m_imp.reset (); }
    }

    recursive_directory_iterator(const path& dir_path,
      system::error_code & ec)
    : m_imp(new detail::recur_dir_itr_imp)
    {
      m_imp->m_options = symlink_option::none;
      m_imp->m_stack.push(directory_iterator(dir_path, ec));
      if (m_imp->m_stack.top() == directory_iterator())
        { m_imp.reset (); }
    }

    recursive_directory_iterator& increment(system::error_code& ec)
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "increment() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 878 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 879
# 878 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                          ;
      m_imp->increment(&ec);
      if (m_imp->m_stack.empty())
        m_imp.reset();
      return *this;
    }

    int level() const
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "level() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 888 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 889
# 888 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                      ;
      return m_imp->m_level;
    }

    bool no_push_pending() const
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "is_no_push_requested() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 895 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 896
# 895 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                                     ;
      return (m_imp->m_options & symlink_option::_detail_no_push)
        == symlink_option::_detail_no_push;
    }


    bool no_push_request() const { return no_push_pending(); }


    void pop()
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "pop() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 907 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 908
# 907 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                    ;
      m_imp->pop();
      if (m_imp->m_stack.empty()) m_imp.reset();
    }

    void no_push(bool value=true)
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "no_push() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 915 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 916
# 915 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                        ;
      if (value)
        m_imp->m_options |= symlink_option::_detail_no_push;
      else
        m_imp->m_options &= ~symlink_option::_detail_no_push;
    }

    file_status status() const
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "status() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 925 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 926
# 925 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                       ;
      return m_imp->m_stack.top()->status();
    }

    file_status symlink_status() const
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "symlink_status() on end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 932 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 933
# 932 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                               ;
      return m_imp->m_stack.top()->symlink_status();
    }

  private:



    boost::shared_ptr< detail::recur_dir_itr_imp > m_imp;

    friend class boost::iterator_core_access;

    boost::iterator_facade<
      recursive_directory_iterator,
      directory_entry,
      boost::single_pass_traversal_tag >::reference
    dereference() const
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "dereference of end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 951 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 952
# 951 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                          ;
      return *m_imp->m_stack.top();
    }

    void increment()
    {
      ((m_imp.get()) ? ((void)0) : ::boost::assertion::detail::assertion_failed_msg("m_imp.get()", "increment of end recursive_directory_iterator", __PRETTY_FUNCTION__,
 "/usr/include/boost/filesystem/operations.hpp"
# 958 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ,
 959
# 958 "/usr/include/boost/filesystem/operations.hpp" 3 4
      ))
                                                        ;
      m_imp->increment(0);
      if (m_imp->m_stack.empty())
        m_imp.reset();
    }

    bool equal(const recursive_directory_iterator& rhs) const
      { return m_imp == rhs.m_imp; }

  };


  typedef recursive_directory_iterator wrecursive_directory_iterator;
# 980 "/usr/include/boost/filesystem/operations.hpp" 3 4
  class __attribute__((visibility("default"))) filesystem_error : public system::system_error
  {




  public:


    filesystem_error(
      const std::string & what_arg, system::error_code ec)
      : system::system_error(ec, what_arg)
    {
      try
      {
        m_imp_ptr.reset(new m_imp);
      }
      catch (...) { m_imp_ptr.reset(); }
    }

    filesystem_error(
      const std::string & what_arg, const path& path1_arg,
      system::error_code ec)
      : system::system_error(ec, what_arg)
    {
      try
      {
        m_imp_ptr.reset(new m_imp);
        m_imp_ptr->m_path1 = path1_arg;
      }
      catch (...) { m_imp_ptr.reset(); }
    }

    filesystem_error(
      const std::string & what_arg, const path& path1_arg,
      const path& path2_arg, system::error_code ec)
      : system::system_error(ec, what_arg)
    {
      try
      {
        m_imp_ptr.reset(new m_imp);
        m_imp_ptr->m_path1 = path1_arg;
        m_imp_ptr->m_path2 = path2_arg;
      }
      catch (...) { m_imp_ptr.reset(); }
    }

    ~filesystem_error() throw() {}

    const path& path1() const
    {
      static const path empty_path;
      return m_imp_ptr.get() ? m_imp_ptr->m_path1 : empty_path ;
    }
    const path& path2() const
    {
      static const path empty_path;
      return m_imp_ptr.get() ? m_imp_ptr->m_path2 : empty_path ;
    }

    const char* what() const throw()
    {
      if (!m_imp_ptr.get())
        return system::system_error::what();

      try
      {
        if (m_imp_ptr->m_what.empty())
        {
          m_imp_ptr->m_what = system::system_error::what();
          if (!m_imp_ptr->m_path1.empty())
          {
            m_imp_ptr->m_what += ": \"";
            m_imp_ptr->m_what += m_imp_ptr->m_path1.string();
            m_imp_ptr->m_what += "\"";
          }
          if (!m_imp_ptr->m_path2.empty())
          {
            m_imp_ptr->m_what += ", \"";
            m_imp_ptr->m_what += m_imp_ptr->m_path2.string();
            m_imp_ptr->m_what += "\"";
          }
        }
        return m_imp_ptr->m_what.c_str();
      }
      catch (...)
      {
        return system::system_error::what();
      }
    }

  private:
    struct m_imp
    {
      path m_path1;
      path m_path2;
      std::string m_what;
    };
    boost::shared_ptr<m_imp> m_imp_ptr;
  };







  namespace detail
  {
    bool possible_large_file_size_support();
  }

  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 1096 "/usr/include/boost/filesystem/operations.hpp" 2 3 4
# 18 "/usr/include/boost/filesystem.hpp" 2 3 4
# 1 "/usr/include/boost/filesystem/convenience.hpp" 1 3 4
# 25 "/usr/include/boost/filesystem/convenience.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 26 "/usr/include/boost/filesystem/convenience.hpp" 2 3 4

namespace boost
{
  namespace filesystem
  {



    inline std::string extension(const path & p)
    {
      return p.extension().string();
    }

    inline std::string basename(const path & p)
    {
      return p.stem().string();
    }

    inline path change_extension( const path & p, const path & new_extension )
    {
      path new_p( p );
      new_p.replace_extension( new_extension );
      return new_p;
    }




  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 58 "/usr/include/boost/filesystem/convenience.hpp" 2 3 4
# 19 "/usr/include/boost/filesystem.hpp" 2 3 4
# 24 "./drizzled/sys_var.h" 2


# 1 "./drizzled/constrained_value.h" 1
# 20 "./drizzled/constrained_value.h"
       

# 1 "/usr/include/boost/exception/info.hpp" 1 3 4
# 9 "/usr/include/boost/exception/info.hpp" 3 4
       
# 10 "/usr/include/boost/exception/info.hpp" 3






# 1 "/usr/include/boost/exception/to_string_stub.hpp" 1 3 4
# 9 "/usr/include/boost/exception/to_string_stub.hpp" 3 4
       
# 10 "/usr/include/boost/exception/to_string_stub.hpp" 3





# 1 "/usr/include/boost/exception/to_string.hpp" 1 3 4
# 9 "/usr/include/boost/exception/to_string.hpp" 3 4
       
# 10 "/usr/include/boost/exception/to_string.hpp" 3






# 1 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 1 3 4
# 9 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 3 4
       
# 10 "/usr/include/boost/exception/detail/is_output_streamable.hpp" 3







namespace
boost
    {
    namespace
    to_string_detail
        {
        struct
        partial_ordering_helper1
            {
            template <class CharT,class Traits>
            partial_ordering_helper1( std::basic_ostream<CharT,Traits> & );
            };

        struct
        partial_ordering_helper2
            {
            template <class T>
            partial_ordering_helper2( T const & );
            };

        char operator<<( partial_ordering_helper1, partial_ordering_helper2 );

        template <class T,class CharT,class Traits>
        struct
        is_output_streamable_impl
            {
            static std::basic_ostream<CharT,Traits> & f();
            static T const & g();
            enum e { value=1!=(sizeof(f()<<g())) };
            };
        }

    template <class T, class CharT=char, class Traits=std::char_traits<CharT> >
    struct
    is_output_streamable
        {
        enum e { value=to_string_detail::is_output_streamable_impl<T,CharT,Traits>::value };
        };
    }
# 17 "/usr/include/boost/exception/to_string.hpp" 2 3


namespace
boost
    {
    namespace
    to_string_detail
        {
        template <class T>
        typename disable_if<is_output_streamable<T>,char>::type to_string( T const & );

        template <class,bool IsOutputStreamable>
        struct has_to_string_impl;

        template <class T>
        struct
        has_to_string_impl<T,true>
            {
            enum e { value=1 };
            };

        template <class T>
        struct
        has_to_string_impl<T,false>
            {
            static T const & f();
            enum e { value=1!=sizeof(to_string(f())) };
            };
        }

    template <class T>
    inline
    typename enable_if<is_output_streamable<T>,std::string>::type
    to_string( T const & x )
        {
        std::ostringstream out;
        out << x;
        return out.str();
        }

    template <class T>
    struct
    has_to_string
        {
        enum e { value=to_string_detail::has_to_string_impl<T,is_output_streamable<T>::value>::value };
        };

    template <class T,class U>
    inline
    std::string
    to_string( std::pair<T,U> const & x )
        {
        return std::string("(") + to_string(x.first) + ',' + to_string(x.second) + ')';
        }

    inline
    std::string
    to_string( std::exception const & x )
        {
        return x.what();
        }
    }
# 16 "/usr/include/boost/exception/to_string_stub.hpp" 2 3
# 1 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 1 3 4
# 9 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 3 4
       
# 10 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 3





# 1 "/usr/include/boost/exception/detail/type_info.hpp" 1 3 4
# 9 "/usr/include/boost/exception/detail/type_info.hpp" 3 4
       
# 10 "/usr/include/boost/exception/detail/type_info.hpp" 3
# 19 "/usr/include/boost/exception/detail/type_info.hpp" 3
# 1 "/usr/include/boost/units/detail/utility.hpp" 1 3 4
# 14 "/usr/include/boost/units/detail/utility.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstdlib" 1 3 4
# 39 "/usr/include/c++/4.8/cstdlib" 3 4
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 15 "/usr/include/boost/units/detail/utility.hpp" 2 3 4





# 1 "/usr/include/c++/4.8/cxxabi.h" 1 3 4
# 44 "/usr/include/c++/4.8/cxxabi.h" 3 4
       
# 45 "/usr/include/c++/4.8/cxxabi.h" 3

#pragma GCC visibility push(default)

# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 49 "/usr/include/c++/4.8/cxxabi.h" 2 3

# 1 "/usr/include/i386-linux-gnu/c++/4.8/bits/cxxabi_tweaks.h" 1 3
# 34 "/usr/include/i386-linux-gnu/c++/4.8/bits/cxxabi_tweaks.h" 3
namespace __cxxabiv1
{
  extern "C"
  {
# 46 "/usr/include/i386-linux-gnu/c++/4.8/bits/cxxabi_tweaks.h" 3
  __extension__ typedef int __guard __attribute__((mode (__DI__)));


  typedef void __cxa_vec_ctor_return_type;


  typedef void __cxa_cdtor_return_type;


  }
}
# 51 "/usr/include/c++/4.8/cxxabi.h" 2 3







namespace __cxxabiv1
{
  extern "C"
  {


  typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);


  void*
  __cxa_vec_new(size_t __element_count, size_t __element_size,
  size_t __padding_size, __cxa_cdtor_type __constructor,
  __cxa_cdtor_type __destructor);

  void*
  __cxa_vec_new2(size_t __element_count, size_t __element_size,
   size_t __padding_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
   void (*__dealloc) (void*));

  void*
  __cxa_vec_new3(size_t __element_count, size_t __element_size,
   size_t __padding_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
   void (*__dealloc) (void*, size_t));


  __cxa_vec_ctor_return_type
  __cxa_vec_ctor(void* __array_address, size_t __element_count,
   size_t __element_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor);

  __cxa_vec_ctor_return_type
  __cxa_vec_cctor(void* __dest_array, void* __src_array,
    size_t __element_count, size_t __element_size,
    __cxa_cdtor_return_type (*__constructor) (void*, void*),
    __cxa_cdtor_type __destructor);


  void
  __cxa_vec_dtor(void* __array_address, size_t __element_count,
   size_t __element_size, __cxa_cdtor_type __destructor);

  void
  __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
      __cxa_cdtor_type __destructor) throw();


  void
  __cxa_vec_delete(void* __array_address, size_t __element_size,
     size_t __padding_size, __cxa_cdtor_type __destructor);

  void
  __cxa_vec_delete2(void* __array_address, size_t __element_size,
      size_t __padding_size, __cxa_cdtor_type __destructor,
      void (*__dealloc) (void*));

  void
  __cxa_vec_delete3(void* __array_address, size_t __element_size,
      size_t __padding_size, __cxa_cdtor_type __destructor,
      void (*__dealloc) (void*, size_t));

  int
  __cxa_guard_acquire(__guard*);

  void
  __cxa_guard_release(__guard*) throw();

  void
  __cxa_guard_abort(__guard*) throw();


  int
  __cxa_atexit(void (*)(void*), void*, void*) throw();

  int
  __cxa_finalize(void*);


  int
  __cxa_thread_atexit(void (*)(void*), void*, void *) throw();


  void
  __cxa_pure_virtual(void) __attribute__ ((__noreturn__));

  void
  __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));


  void
  __cxa_bad_cast() __attribute__((__noreturn__));

  void
  __cxa_bad_typeid() __attribute__((__noreturn__));
# 195 "/usr/include/c++/4.8/cxxabi.h" 3
  char*
  __cxa_demangle(const char* __mangled_name, char* __output_buffer,
   size_t* __length, int* __status);


  }
}






namespace __cxxabiv1
{

  class __fundamental_type_info : public std::type_info
  {
  public:
    explicit
    __fundamental_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__fundamental_type_info();
  };


  class __array_type_info : public std::type_info
  {
  public:
    explicit
    __array_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__array_type_info();
  };


  class __function_type_info : public std::type_info
  {
  public:
    explicit
    __function_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__function_type_info();

  protected:

    virtual bool
    __is_function_p() const;
  };


  class __enum_type_info : public std::type_info
  {
  public:
    explicit
    __enum_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__enum_type_info();
  };


  class __pbase_type_info : public std::type_info
  {
  public:
    unsigned int __flags;
    const std::type_info* __pointee;

    explicit
    __pbase_type_info(const char* __n, int __quals,
        const std::type_info* __type)
    : std::type_info(__n), __flags(__quals), __pointee(__type)
    { }

    virtual
    ~__pbase_type_info();


    enum __masks
      {
 __const_mask = 0x1,
 __volatile_mask = 0x2,
 __restrict_mask = 0x4,
 __incomplete_mask = 0x8,
 __incomplete_class_mask = 0x10
      };

  protected:
    __pbase_type_info(const __pbase_type_info&);

    __pbase_type_info&
    operator=(const __pbase_type_info&);


    virtual bool
    __do_catch(const std::type_info* __thr_type, void** __thr_obj,
        unsigned int __outer) const;

    inline virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };


  class __pointer_type_info : public __pbase_type_info
  {
  public:
    explicit
    __pointer_type_info(const char* __n, int __quals,
   const std::type_info* __type)
    : __pbase_type_info (__n, __quals, __type) { }


    virtual
    ~__pointer_type_info();

  protected:

    virtual bool
    __is_pointer_p() const;

    virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };

  class __class_type_info;


  class __pointer_to_member_type_info : public __pbase_type_info
  {
  public:
    __class_type_info* __context;

    explicit
    __pointer_to_member_type_info(const char* __n, int __quals,
      const std::type_info* __type,
      __class_type_info* __klass)
    : __pbase_type_info(__n, __quals, __type), __context(__klass) { }

    virtual
    ~__pointer_to_member_type_info();

  protected:
    __pointer_to_member_type_info(const __pointer_to_member_type_info&);

    __pointer_to_member_type_info&
    operator=(const __pointer_to_member_type_info&);


    virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };


  class __base_class_type_info
  {
  public:
    const __class_type_info* __base_type;



    long __offset_flags;


    enum __offset_flags_masks
      {
 __virtual_mask = 0x1,
 __public_mask = 0x2,
 __hwm_bit = 2,
 __offset_shift = 8
      };


    bool
    __is_virtual_p() const
    { return __offset_flags & __virtual_mask; }

    bool
    __is_public_p() const
    { return __offset_flags & __public_mask; }

    ptrdiff_t
    __offset() const
    {



      return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
    }
  };


  class __class_type_info : public std::type_info
  {
  public:
    explicit
    __class_type_info (const char *__n) : type_info(__n) { }

    virtual
    ~__class_type_info ();






    enum __sub_kind
      {

 __unknown = 0,



 __not_contained,


 __contained_ambig,


 __contained_virtual_mask = __base_class_type_info::__virtual_mask,


 __contained_public_mask = __base_class_type_info::__public_mask,


 __contained_mask = 1 << __base_class_type_info::__hwm_bit,

 __contained_private = __contained_mask,
 __contained_public = __contained_mask | __contained_public_mask
      };

    struct __upcast_result;
    struct __dyncast_result;

  protected:

    virtual bool
    __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;

    virtual bool
    __do_catch(const type_info* __thr_type, void** __thr_obj,
        unsigned __outer) const;

  public:


    virtual bool
    __do_upcast(const __class_type_info* __dst, const void* __obj,
  __upcast_result& __restrict __result) const;







    inline __sub_kind
    __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
        const __class_type_info* __src_type,
        const void* __src_ptr) const;
# 468 "/usr/include/c++/4.8/cxxabi.h" 3
    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;





    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __src_ptr) const;
  };


  class __si_class_type_info : public __class_type_info
  {
  public:
    const __class_type_info* __base_type;

    explicit
    __si_class_type_info(const char *__n, const __class_type_info *__base)
    : __class_type_info(__n), __base_type(__base) { }

    virtual
    ~__si_class_type_info();

  protected:
    __si_class_type_info(const __si_class_type_info&);

    __si_class_type_info&
    operator=(const __si_class_type_info&);


    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;

    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __sub_ptr) const;

    virtual bool
    __do_upcast(const __class_type_info*__dst, const void*__obj,
  __upcast_result& __restrict __result) const;
  };


  class __vmi_class_type_info : public __class_type_info
  {
  public:
    unsigned int __flags;
    unsigned int __base_count;




    __base_class_type_info __base_info[1];

    explicit
    __vmi_class_type_info(const char* __n, int ___flags)
    : __class_type_info(__n), __flags(___flags), __base_count(0) { }

    virtual
    ~__vmi_class_type_info();


    enum __flags_masks
      {
 __non_diamond_repeat_mask = 0x1,
 __diamond_shaped_mask = 0x2,
 __flags_unknown_mask = 0x10
      };

  protected:

    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;

    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __src_ptr) const;

    virtual bool
    __do_upcast(const __class_type_info* __dst, const void* __obj,
  __upcast_result& __restrict __result) const;
  };


  struct __cxa_exception;
  struct __cxa_refcounted_exception;
  struct __cxa_dependent_exception;
  struct __cxa_eh_globals;

  extern "C"
  {
# 581 "/usr/include/c++/4.8/cxxabi.h" 3
  void*
  __dynamic_cast(const void* __src_ptr,
   const __class_type_info* __src_type,
   const __class_type_info* __dst_type,
   ptrdiff_t __src2dst);
# 594 "/usr/include/c++/4.8/cxxabi.h" 3
  __cxa_eh_globals*
  __cxa_get_globals() throw() __attribute__ ((__const__));

  __cxa_eh_globals*
  __cxa_get_globals_fast() throw() __attribute__ ((__const__));


  void*
  __cxa_allocate_exception(size_t) throw();


  void
  __cxa_free_exception(void*) throw();


  void
  __cxa_throw(void*, std::type_info*, void ( *) (void *))
  __attribute__((__noreturn__));


  void*
  __cxa_get_exception_ptr(void*) throw() __attribute__ ((__pure__));

  void*
  __cxa_begin_catch(void*) throw();

  void
  __cxa_end_catch();

  void
  __cxa_rethrow() __attribute__((__noreturn__));



  std::type_info*
  __cxa_current_exception_type() throw() __attribute__ ((__pure__));




  __cxa_dependent_exception*
  __cxa_allocate_dependent_exception() throw();


  void
  __cxa_free_dependent_exception(__cxa_dependent_exception*) throw();

  }



  class __foreign_exception
  {
    virtual ~__foreign_exception() throw();
    virtual void __pure_dummy() = 0;
  };

}
# 673 "/usr/include/c++/4.8/cxxabi.h" 3
namespace abi = __cxxabiv1;

namespace __gnu_cxx
{
# 689 "/usr/include/c++/4.8/cxxabi.h" 3
  class recursive_init_error: public std::exception
  {
  public:
    recursive_init_error() throw() { }
    virtual ~recursive_init_error() throw ();
  };
}


#pragma GCC visibility pop
# 21 "/usr/include/boost/units/detail/utility.hpp" 2 3 4






namespace boost {

namespace units {

namespace detail {

inline
std::string
demangle(const char* name)
{

    char* realname;
    std::size_t len;
    int stat;

    realname = abi::__cxa_demangle(name,__null,&len,&stat);

    if (realname != __null)
    {
        std::string out(realname);

        std::free(realname);

        boost::replace_all(out,"boost::units::","");

        return out;
    }

    return std::string("demangle :: error - unable to demangle specified symbol");
}

}

template<class L>
std::string simplify_typename(const L& )
{
    const std::string demangled = detail::demangle(typeid(L).name());

    return demangled;
}

}

}
# 20 "/usr/include/boost/exception/detail/type_info.hpp" 2 3



namespace
boost
    {
    template <class T>
    inline
    std::string
    tag_type_name()
        {



        return units::detail::demangle(typeid(T*).name());

        }

    template <class T>
    inline
    std::string
    type_name()
        {



        return units::detail::demangle(typeid(T).name());

        }

    namespace
    exception_detail
        {
        struct
        type_info_
            {
            detail::sp_typeinfo const * type_;

            explicit
            type_info_( detail::sp_typeinfo const & type ):
                type_(&type)
                {
                }

            friend
            bool
            operator<( type_info_ const & a, type_info_ const & b )
                {
                return 0!=(a.type_->before(*b.type_));
                }
            };
        }
    }
# 16 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3




# 1 "/usr/include/c++/4.8/cstdlib" 1 3
# 39 "/usr/include/c++/4.8/cstdlib" 3
       
# 40 "/usr/include/c++/4.8/cstdlib" 3
# 21 "/usr/include/boost/exception/detail/object_hex_dump.hpp" 2 3

namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        inline
        std::string
        object_hex_dump( T const & x, std::size_t max_size=16 )
            {
            std::ostringstream s;
            s << "type: " << type_name<T>() << ", size: " << sizeof(T) << ", dump: ";
            std::size_t n=sizeof(T)>max_size?max_size:sizeof(T);
            s.fill('0');
            s.width(2);
            unsigned char const * b=reinterpret_cast<unsigned char const *>(&x);
            s << std::setw(2) << std::hex << (unsigned int)*b;
            for( unsigned char const * e=b+n; ++b!=e; )
                s << " " << std::setw(2) << std::hex << (unsigned int)*b;
            return s.str();
            }
        }
    }
# 17 "/usr/include/boost/exception/to_string_stub.hpp" 2 3
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 50 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 51 "/usr/include/boost/assert.hpp" 2 3 4
# 18 "/usr/include/boost/exception/to_string_stub.hpp" 2 3

namespace
boost
    {
    namespace
    exception_detail
        {
        template <bool ToStringAvailable>
        struct
        to_string_dispatcher
            {
            template <class T,class Stub>
            static
            std::string
            convert( T const & x, Stub )
                {
                return to_string(x);
                }
            };

        template <>
        struct
        to_string_dispatcher<false>
            {
            template <class T,class Stub>
            static
            std::string
            convert( T const & x, Stub s )
                {
                return s(x);
                }

            template <class T>
            static
            std::string
            convert( T const & x, std::string s )
                {
                return s;
                }

            template <class T>
            static
            std::string
            convert( T const & x, char const * s )
                {
                ((s!=0) ? static_cast<void> (0) : __assert_fail ("s!=0", "/usr/include/boost/exception/to_string_stub.hpp", 63, __PRETTY_FUNCTION__));
                return s;
                }
            };

        namespace
        to_string_dispatch
            {
            template <class T,class Stub>
            inline
            std::string
            dispatch( T const & x, Stub s )
                {
                return to_string_dispatcher<has_to_string<T>::value>::convert(x,s);
                }
            }

        template <class T>
        inline
        std::string
        string_stub_dump( T const & x )
            {
            return "[ " + exception_detail::object_hex_dump(x) + " ]";
            }
        }

    template <class T>
    inline
    std::string
    to_string_stub( T const & x )
        {
        return exception_detail::to_string_dispatch::dispatch(x,&exception_detail::string_stub_dump<T>);
        }

    template <class T,class Stub>
    inline
    std::string
    to_string_stub( T const & x, Stub s )
        {
        return exception_detail::to_string_dispatch::dispatch(x,s);
        }
    }
# 17 "/usr/include/boost/exception/info.hpp" 2 3
# 1 "/usr/include/boost/exception/detail/error_info_impl.hpp" 1 3 4
# 9 "/usr/include/boost/exception/detail/error_info_impl.hpp" 3 4
       
# 10 "/usr/include/boost/exception/detail/error_info_impl.hpp" 3







namespace
boost
    {
    namespace
    exception_detail
        {
        class
        error_info_base
            {
            public:

            virtual std::string tag_typeid_name() const = 0;
            virtual std::string value_as_string() const = 0;

            protected:

            virtual
            ~error_info_base() throw()
                {
                }
            };
        }

    template <class Tag,class T>
    class
    error_info:
        public exception_detail::error_info_base
        {
        public:

        typedef T value_type;

        error_info( value_type const & value );
        ~error_info() throw();

        value_type const &
        value() const
            {
            return value_;
            }

        value_type &
        value()
            {
            return value_;
            }

        private:

        std::string tag_typeid_name() const;
        std::string value_as_string() const;

        value_type value_;
        };
    }
# 18 "/usr/include/boost/exception/info.hpp" 2 3




namespace
boost
    {
    template <class Tag,class T>
    inline
    typename enable_if<has_to_string<T>,std::string>::type
    to_string( error_info<Tag,T> const & x )
        {
        return to_string(x.value());
        }

    template <class Tag,class T>
    inline
    error_info<Tag,T>::
    error_info( value_type const & value ):
        value_(value)
        {
        }

    template <class Tag,class T>
    inline
    error_info<Tag,T>::
    ~error_info() throw()
        {
        }

    template <class Tag,class T>
    inline
    std::string
    error_info<Tag,T>::
    tag_typeid_name() const
        {
        return tag_type_name<Tag>();
        }

    template <class Tag,class T>
    inline
    std::string
    error_info<Tag,T>::
    value_as_string() const
        {
        return to_string_stub(*this);
        }

    namespace
    exception_detail
        {
        class
        error_info_container_impl:
            public error_info_container
            {
            public:

            error_info_container_impl():
                count_(0)
                {
                }

            ~error_info_container_impl() throw()
                {
                }

            void
            set( shared_ptr<error_info_base> const & x, type_info_ const & typeid_ )
                {
                ((x) ? static_cast<void> (0) : __assert_fail ("x", "/usr/include/boost/exception/info.hpp", 87, __PRETTY_FUNCTION__));
                info_[typeid_] = x;
                diagnostic_info_str_.clear();
                }

            shared_ptr<error_info_base>
            get( type_info_ const & ti ) const
                {
                error_info_map::const_iterator i=info_.find(ti);
                if( info_.end()!=i )
                    {
                    shared_ptr<error_info_base> const & p = i->second;

                    ((*::boost::exception_detail::type_info_(typeid(*p)).type_==*ti.type_) ? static_cast<void> (0) : __assert_fail ("*::boost::exception_detail::type_info_(typeid(*p)).type_==*ti.type_", "/usr/include/boost/exception/info.hpp", 100, __PRETTY_FUNCTION__));

                    return p;
                    }
                return shared_ptr<error_info_base>();
                }

            char const *
            diagnostic_information( char const * header ) const
                {
                if( header )
                    {
                    std::ostringstream tmp;
                    tmp << header;
                    for( error_info_map::const_iterator i=info_.begin(),end=info_.end(); i!=end; ++i )
                        {
                        error_info_base const & x = *i->second;
                        tmp << '[' << x.tag_typeid_name() << "] = " << x.value_as_string() << '\n';
                        }
                    tmp.str().swap(diagnostic_info_str_);
                    }
                return diagnostic_info_str_.c_str();
                }

            private:

            friend class boost::exception;

            typedef std::map< type_info_, shared_ptr<error_info_base> > error_info_map;
            error_info_map info_;
            mutable std::string diagnostic_info_str_;
            mutable int count_;

            error_info_container_impl( error_info_container_impl const & );
            error_info_container_impl & operator=( error_info_container const & );

            void
            add_ref() const
                {
                ++count_;
                }

            bool
            release() const
                {
                if( --count_ )
                    return false;
                else
                    {
                    delete this;
                    return true;
                    }
                }

            refcount_ptr<error_info_container>
            clone() const
                {
                refcount_ptr<error_info_container> p;
                error_info_container_impl * c=new error_info_container_impl;
                p.adopt(c);
                c->info_ = info_;
                return p;
                }
            };

        template <class E,class Tag,class T>
        inline
        E const &
        set_info( E const & x, error_info<Tag,T> const & v )
            {
            typedef error_info<Tag,T> error_info_tag_t;
            shared_ptr<error_info_tag_t> p( new error_info_tag_t(v) );
            exception_detail::error_info_container * c=x.data_.get();
            if( !c )
                x.data_.adopt(c=new exception_detail::error_info_container_impl);
            c->set(p,::boost::exception_detail::type_info_(typeid(error_info_tag_t)));
            return x;
            }

        template <class T>
        struct
        derives_boost_exception
            {
            enum e { value = (sizeof(dispatch_boost_exception((T*)0))==sizeof(large_size)) };
            };
        }

    template <class E,class Tag,class T>
    inline
    typename enable_if<exception_detail::derives_boost_exception<E>,E const &>::type
    operator<<( E const & x, error_info<Tag,T> const & v )
        {
        return exception_detail::set_info(x,v);
        }
    }
# 23 "./drizzled/constrained_value.h" 2
# 1 "/usr/include/boost/program_options.hpp" 1 3 4
# 15 "/usr/include/boost/program_options.hpp" 3 4
# 1 "/usr/include/boost/program_options/options_description.hpp" 1 3 4
# 11 "/usr/include/boost/program_options/options_description.hpp" 3 4
# 1 "/usr/include/boost/program_options/config.hpp" 1 3 4
# 30 "/usr/include/boost/program_options/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 31 "/usr/include/boost/program_options/config.hpp" 2 3 4
# 12 "/usr/include/boost/program_options/options_description.hpp" 2 3 4
# 1 "/usr/include/boost/program_options/errors.hpp" 1 3 4
# 24 "/usr/include/boost/program_options/errors.hpp" 3 4
namespace boost { namespace program_options {

    inline std::string strip_prefixes(const std::string& text)
    {
        return text.substr(text.find_last_of("-/") + 1);
    }


    class error : public std::logic_error {
    public:
        error(const std::string& xwhat) : std::logic_error(xwhat) {}
    };





    class too_many_positional_options_error : public error {
    public:
        too_many_positional_options_error()
         : error("too many positional options have been specified on the command line")
        {}
    };


    class invalid_command_line_style : public error {
    public:
        invalid_command_line_style(const std::string& msg)
        : error(msg)
        {}
    };


    class reading_file : public error {
    public:
        reading_file(const char* filename)
         : error(std::string("can not read options configuration file '").append(filename).append("'"))
        {}
    };
# 88 "/usr/include/boost/program_options/errors.hpp" 3 4
    class error_with_option_name : public error {

    protected:






        int m_option_style;




        std::map<std::string, std::string> m_substitutions;
        typedef std::pair<std::string, std::string> string_pair;
        std::map<std::string, string_pair > m_substitution_defaults;

    public:

  std::string m_error_template;

  error_with_option_name(const std::string& template_,
                              const std::string& option_name = "",
                              const std::string& original_token = "",
                              int option_style = 0);




        ~error_with_option_name() throw() {}
# 141 "/usr/include/boost/program_options/errors.hpp" 3 4
        void set_substitute(const std::string& parameter_name, const std::string& value)
        { m_substitutions[parameter_name] = value; }



        void set_substitute_default(const std::string& parameter_name,
                                    const std::string& from,
                                    const std::string& to)
        {
            m_substitution_defaults[parameter_name] = std::make_pair(from, to);
        }



        void add_context(const std::string& option_name,
                         const std::string& original_token,
                         int option_style)
        {
            set_option_name(option_name);
            set_original_token(original_token);
            set_prefix(option_style);
        }

        void set_prefix(int option_style)
        { m_option_style = option_style;}


        virtual void set_option_name(const std::string& option_name)
        { set_substitute("option", option_name);}

        std::string get_option_name() const throw()
        { return get_canonical_option_name(); }

        void set_original_token(const std::string& original_token)
        { set_substitute("original_token", original_token);}




        virtual const char* what() const throw();

    protected:

        mutable std::string m_message;


        virtual void substitute_placeholders(const std::string& error_template) const;


        void replace_token(const std::string& from, const std::string& to) const;



        std::string get_canonical_option_name() const;
        std::string get_canonical_option_prefix() const;
    };




    class multiple_values : public error_with_option_name {
    public:
        multiple_values()
         : error_with_option_name("option '%canonical_option%' only takes a single argument"){}

        ~multiple_values() throw() {}
    };




    class multiple_occurrences : public error_with_option_name {
    public:
        multiple_occurrences()
         : error_with_option_name("option '%canonical_option%' cannot be specified more than once"){}

        ~multiple_occurrences() throw() {}

    };


    class required_option : public error_with_option_name {
    public:

       required_option(const std::string& option_name)
       : error_with_option_name("the option '%canonical_option%' is required but missing", "", option_name)
       {
       }

       ~required_option() throw() {}
    };
# 244 "/usr/include/boost/program_options/errors.hpp" 3 4
    class error_with_no_option_name : public error_with_option_name {
    public:
        error_with_no_option_name(const std::string& template_,
                              const std::string& original_token = "")
        : error_with_option_name(template_, "", original_token)
        {
        }


        virtual void set_option_name(const std::string&) {}

        ~error_with_no_option_name() throw() {}
    };



    class unknown_option : public error_with_no_option_name {
    public:
        unknown_option(const std::string& original_token = "")
        : error_with_no_option_name("unrecognised option '%canonical_option%'", original_token)
        {
        }

        ~unknown_option() throw() {}
    };




    class ambiguous_option : public error_with_no_option_name {
    public:
        ambiguous_option(const std::vector<std::string>& xalternatives)
        : error_with_no_option_name("option '%canonical_option%' is ambiguous"),
            m_alternatives(xalternatives)
        {}

        ~ambiguous_option() throw() {}

        const std::vector<std::string>& alternatives() const throw() {return m_alternatives;}

    protected:

        virtual void substitute_placeholders(const std::string& error_template) const;
    private:

        std::vector<std::string> m_alternatives;
    };





    class invalid_syntax : public error_with_option_name {
    public:
        enum kind_t {
            long_not_allowed = 30,
            long_adjacent_not_allowed,
            short_adjacent_not_allowed,
            empty_adjacent_parameter,
            missing_parameter,
            extra_parameter,
            unrecognized_line
        };

        invalid_syntax(kind_t kind,
                       const std::string& option_name = "",
                       const std::string& original_token = "",
                       int option_style = 0):
            error_with_option_name(get_template(kind), option_name, original_token, option_style),
            m_kind(kind)
        {
        }

        ~invalid_syntax() throw() {}

        kind_t kind() const {return m_kind;}


        virtual std::string tokens() const {return get_option_name(); }
    protected:

        std::string get_template(kind_t kind);
        kind_t m_kind;
    };

    class invalid_config_file_syntax : public invalid_syntax {
    public:
        invalid_config_file_syntax(const std::string& invalid_line, kind_t kind):
            invalid_syntax(kind)
        {
            m_substitutions["invalid_line"] = invalid_line;
        }

        ~invalid_config_file_syntax() throw() {}


        virtual std::string tokens() const {return m_substitutions.find("invalid_line")->second; }
    };



    class invalid_command_line_syntax : public invalid_syntax {
    public:
        invalid_command_line_syntax(kind_t kind,
                       const std::string& option_name = "",
                       const std::string& original_token = "",
                       int option_style = 0):
            invalid_syntax(kind, option_name, original_token, option_style) {}
        ~invalid_command_line_syntax() throw() {}
    };



    class validation_error : public error_with_option_name {
    public:
        enum kind_t {
            multiple_values_not_allowed = 30,
            at_least_one_value_required,
            invalid_bool_value,
            invalid_option_value,
            invalid_option
        };

    public:
        validation_error(kind_t kind,
                   const std::string& option_name = "",
                   const std::string& original_token = "",
                   int option_style = 0):
        error_with_option_name(get_template(kind), option_name, original_token, option_style)
        {
        }

        ~validation_error() throw() {}

    protected:

        std::string get_template(kind_t kind);
        kind_t m_kind;
    };


    class invalid_option_value
        : public validation_error
    {
    public:
        invalid_option_value(const std::string& value);

        invalid_option_value(const std::wstring& value);

    };


    class invalid_bool_value
        : public validation_error
    {
    public:
        invalid_bool_value(const std::string& value);
    };







}}
# 13 "/usr/include/boost/program_options/options_description.hpp" 2 3 4
# 1 "/usr/include/boost/program_options/value_semantic.hpp" 1 3 4
# 12 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
# 1 "/usr/include/boost/any.hpp" 1 3 4
# 30 "/usr/include/boost/any.hpp" 3 4
# 1 "/usr/include/c++/4.8/cstring" 1 3 4
# 39 "/usr/include/c++/4.8/cstring" 3 4
       
# 40 "/usr/include/c++/4.8/cstring" 3
# 31 "/usr/include/boost/any.hpp" 2 3 4


namespace boost
{
    class any
    {
    public:

        any()
          : content(0)
        {
        }

        template<typename ValueType>
        any(const ValueType & value)
          : content(new holder<ValueType>(value))
        {
        }

        any(const any & other)
          : content(other.content ? other.content->clone() : 0)
        {
        }

        ~any()
        {
            delete content;
        }

    public:

        any & swap(any & rhs)
        {
            std::swap(content, rhs.content);
            return *this;
        }

        template<typename ValueType>
        any & operator=(const ValueType & rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }

        any & operator=(any rhs)
        {
            rhs.swap(*this);
            return *this;
        }

    public:

        bool empty() const
        {
            return !content;
        }

        const std::type_info & type() const
        {
            return content ? content->type() : typeid(void);
        }


    private:




        class placeholder
        {
        public:

            virtual ~placeholder()
            {
            }

        public:

            virtual const std::type_info & type() const = 0;

            virtual placeholder * clone() const = 0;

        };

        template<typename ValueType>
        class holder : public placeholder
        {
        public:

            holder(const ValueType & value)
              : held(value)
            {
            }

        public:

            virtual const std::type_info & type() const
            {
                return typeid(ValueType);
            }

            virtual placeholder * clone() const
            {
                return new holder(held);
            }

        public:

            ValueType held;

        private:
            holder & operator=(const holder &);
        };



    private:

        template<typename ValueType>
        friend ValueType * any_cast(any *);

        template<typename ValueType>
        friend ValueType * unsafe_any_cast(any *);







        placeholder * content;

    };

    class bad_any_cast : public std::bad_cast
    {
    public:
        virtual const char * what() const throw()
        {
            return "boost::bad_any_cast: "
                   "failed conversion using boost::any_cast";
        }
    };

    template<typename ValueType>
    ValueType * any_cast(any * operand)
    {
        return operand &&

            std::strcmp(operand->type().name(), typeid(ValueType).name()) == 0



            ? &static_cast<any::holder<ValueType> *>(operand->content)->held
            : 0;
    }

    template<typename ValueType>
    inline const ValueType * any_cast(const any * operand)
    {
        return any_cast<ValueType>(const_cast<any *>(operand));
    }

    template<typename ValueType>
    ValueType any_cast(any & operand)
    {
        typedef typename remove_reference<ValueType>::type nonref;
# 209 "/usr/include/boost/any.hpp" 3 4
        nonref * result = any_cast<nonref>(&operand);
        if(!result)
            boost::throw_exception(bad_any_cast());
        return *result;
    }

    template<typename ValueType>
    inline ValueType any_cast(const any & operand)
    {
        typedef typename remove_reference<ValueType>::type nonref;







        return any_cast<const nonref &>(const_cast<any &>(operand));
    }






    template<typename ValueType>
    inline ValueType * unsafe_any_cast(any * operand)
    {
        return &static_cast<any::holder<ValueType> *>(operand->content)->held;
    }

    template<typename ValueType>
    inline const ValueType * unsafe_any_cast(const any * operand)
    {
        return unsafe_any_cast<ValueType>(const_cast<any *>(operand));
    }
}
# 13 "/usr/include/boost/program_options/value_semantic.hpp" 2 3 4
# 1 "/usr/include/boost/function/function1.hpp" 1 3 4
# 11 "/usr/include/boost/function/function1.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 12 "/usr/include/boost/function/function1.hpp" 2 3 4
# 14 "/usr/include/boost/program_options/value_semantic.hpp" 2 3 4







namespace boost { namespace program_options {




    class value_semantic {
    public:



        virtual std::string name() const = 0;



        virtual unsigned min_tokens() const = 0;



        virtual unsigned max_tokens() const = 0;





        virtual bool is_composing() const = 0;




        virtual bool is_required() const = 0;






        virtual void parse(boost::any& value_store,
                           const std::vector<std::string>& new_tokens,
                           bool utf8) const
            = 0;




        virtual bool apply_default(boost::any& value_store) const = 0;



        virtual void notify(const boost::any& value_store) const = 0;

        virtual ~value_semantic() {}
    };




    template<class charT>
    class value_semantic_codecvt_helper {

    };
# 89 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
    template<>
    class
    value_semantic_codecvt_helper<char> : public value_semantic {
    private:
        void parse(boost::any& value_store,
                   const std::vector<std::string>& new_tokens,
                   bool utf8) const;
    protected:
        virtual void xparse(boost::any& value_store,
                            const std::vector<std::string>& new_tokens)
            const = 0;
    };
# 109 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
    template<>
    class
    value_semantic_codecvt_helper<wchar_t> : public value_semantic {
    private:
        void parse(boost::any& value_store,
                   const std::vector<std::string>& new_tokens,
                   bool utf8) const;
    protected:

        virtual void xparse(boost::any& value_store,
                            const std::vector<std::wstring>& new_tokens)
            const = 0;

    };



    class
    untyped_value : public value_semantic_codecvt_helper<char> {
    public:
        untyped_value(bool zero_tokens = false)
        : m_zero_tokens(zero_tokens)
        {}

        std::string name() const;

        unsigned min_tokens() const;
        unsigned max_tokens() const;

        bool is_composing() const { return false; }

        bool is_required() const { return false; }






        void xparse(boost::any& value_store,
                    const std::vector<std::string>& new_tokens) const;


        bool apply_default(boost::any&) const { return false; }


        void notify(const boost::any&) const {}
    private:
        bool m_zero_tokens;
    };







    class typed_value_base
    {
    public:


        virtual const std::type_info& value_type() const = 0;


        virtual ~typed_value_base() {}
    };



    template<class T, class charT = char>
    class typed_value : public value_semantic_codecvt_helper<charT>,
                        public typed_value_base
    {
    public:


        typed_value(T* store_to)
        : m_store_to(store_to), m_composing(false),
          m_multitoken(false), m_zero_tokens(false),
          m_required(false)
        {}





        typed_value* default_value(const T& v)
        {
            m_default_value = boost::any(v);
            m_default_value_as_text = boost::lexical_cast<std::string>(v);
            return this;
        }







        typed_value* default_value(const T& v, const std::string& textual)
        {
            m_default_value = boost::any(v);
            m_default_value_as_text = textual;
            return this;
        }
# 222 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
        typed_value* implicit_value(const T &v)
        {
            m_implicit_value = boost::any(v);
            m_implicit_value_as_text =
                boost::lexical_cast<std::string>(v);
            return this;
        }


        typed_value* value_name(const std::string& name)
        {
            m_value_name = name;
            return this;
        }
# 247 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
        typed_value* implicit_value(const T &v, const std::string& textual)
        {
            m_implicit_value = boost::any(v);
            m_implicit_value_as_text = textual;
            return this;
        }



        typed_value* notifier(function1<void, const T&> f)
        {
            m_notifier = f;
            return this;
        }




        typed_value* composing()
        {
            m_composing = true;
            return this;
        }



        typed_value* multitoken()
        {
            m_multitoken = true;
            return this;
        }
# 286 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
        typed_value* zero_tokens()
        {
            m_zero_tokens = true;
            return this;
        }


        typed_value* required()
        {
            m_required = true;
            return this;
        }

    public:

        std::string name() const;

        bool is_composing() const { return m_composing; }

        unsigned min_tokens() const
        {
            if (m_zero_tokens || !m_implicit_value.empty()) {
                return 0;
            } else {
                return 1;
            }
        }

        unsigned max_tokens() const {
            if (m_multitoken) {
                return 32000;
            } else if (m_zero_tokens) {
                return 0;
            } else {
                return 1;
            }
        }

        bool is_required() const { return m_required; }



        void xparse(boost::any& value_store,
                    const std::vector< std::basic_string<charT> >& new_tokens)
            const;





        virtual bool apply_default(boost::any& value_store) const
        {
            if (m_default_value.empty()) {
                return false;
            } else {
                value_store = m_default_value;
                return true;
            }
        }




        void notify(const boost::any& value_store) const;

    public:

        const std::type_info& value_type() const
        {
            return typeid(T);
        }


    private:
        T* m_store_to;



        std::string m_value_name;
        boost::any m_default_value;
        std::string m_default_value_as_text;
        boost::any m_implicit_value;
        std::string m_implicit_value_as_text;
        bool m_composing, m_implicit, m_multitoken, m_zero_tokens, m_required;
        boost::function1<void, const T&> m_notifier;
    };
# 380 "/usr/include/boost/program_options/value_semantic.hpp" 3 4
    template<class T>
    typed_value<T>*
    value();



    template<class T>
    typed_value<T>*
    value(T* v);





    template<class T>
    typed_value<T, wchar_t>*
    wvalue();



    template<class T>
    typed_value<T, wchar_t>*
    wvalue(T* v);





    typed_value<bool>*
    bool_switch();



    typed_value<bool>*
    bool_switch(bool* v);

}}

# 1 "/usr/include/boost/program_options/detail/value_semantic.hpp" 1 3 4
# 11 "/usr/include/boost/program_options/detail/value_semantic.hpp" 3 4
namespace boost { namespace program_options {

    extern std::string arg;

    template<class T, class charT>
    std::string
    typed_value<T, charT>::name() const
    {
        std::string const& var = (m_value_name.empty() ? arg : m_value_name);
        if (!m_implicit_value.empty() && !m_implicit_value_as_text.empty()) {
            std::string msg = "[=" + var + "(=" + m_implicit_value_as_text + ")]";
            if (!m_default_value.empty() && !m_default_value_as_text.empty())
                msg += " (=" + m_default_value_as_text + ")";
            return msg;
        }
        else if (!m_default_value.empty() && !m_default_value_as_text.empty()) {
            return var + " (=" + m_default_value_as_text + ")";
        } else {
            return var;
        }
    }

    template<class T, class charT>
    void
    typed_value<T, charT>::notify(const boost::any& value_store) const
    {
        const T* value = boost::any_cast<T>(&value_store);
        if (m_store_to) {
            *m_store_to = *value;
        }
        if (m_notifier) {
            m_notifier(*value);
        }
    }

    namespace validators {





        template<class charT>
        const std::basic_string<charT>& get_single_string(
            const std::vector<std::basic_string<charT> >& v,
            bool allow_empty = false)
        {
            static std::basic_string<charT> empty;
            if (v.size() > 1)
                boost::throw_exception(validation_error(validation_error::multiple_values_not_allowed));
            else if (v.size() == 1)
                return v.front();
            else if (!allow_empty)
                boost::throw_exception(validation_error(validation_error::at_least_one_value_required));
            return empty;
        }


        void
        check_first_occurrence(const boost::any& value);
    }

    using namespace validators;
# 81 "/usr/include/boost/program_options/detail/value_semantic.hpp" 3 4
    template<class T, class charT>
    void validate(boost::any& v,
                  const std::vector< std::basic_string<charT> >& xs,
                  T*, long)
    {
        validators::check_first_occurrence(v);
        std::basic_string<charT> s(validators::get_single_string(xs));
        try {
            v = any(lexical_cast<T>(s));
        }
        catch(const bad_lexical_cast&) {
            boost::throw_exception(invalid_option_value(s));
        }
    }

    void validate(boost::any& v,
                       const std::vector<std::string>& xs,
                       bool*,
                       int);


    void validate(boost::any& v,
                       const std::vector<std::wstring>& xs,
                       bool*,
                       int);
# 114 "/usr/include/boost/program_options/detail/value_semantic.hpp" 3 4
    void validate(boost::any& v,
                       const std::vector<std::string>& xs,
                       std::string*,
                       int);


    void validate(boost::any& v,
                       const std::vector<std::wstring>& xs,
                       std::string*,
                       int);





    template<class T, class charT>
    void validate(boost::any& v,
                  const std::vector<std::basic_string<charT> >& s,
                  std::vector<T>*,
                  int)
    {
        if (v.empty()) {
            v = boost::any(std::vector<T>());
        }
        std::vector<T>* tv = boost::any_cast< std::vector<T> >(&v);
        ((__null != tv) ? static_cast<void> (0) : __assert_fail ("__null != tv", "/usr/include/boost/program_options/detail/value_semantic.hpp", 139, __PRETTY_FUNCTION__));
        for (unsigned i = 0; i < s.size(); ++i)
        {
            try {



                boost::any a;
                std::vector<std::basic_string<charT> > cv;
                cv.push_back(s[i]);
                validate(a, cv, (T*)0, 0);
                tv->push_back(boost::any_cast<T>(a));
            }
            catch(const bad_lexical_cast& ) {
                boost::throw_exception(invalid_option_value(s[i]));
            }
        }
    }

    template<class T, class charT>
    void
    typed_value<T, charT>::
    xparse(boost::any& value_store,
           const std::vector<std::basic_string<charT> >& new_tokens) const
    {



        if (new_tokens.empty() && !m_implicit_value.empty())
            value_store = m_implicit_value;
        else
            validate(value_store, new_tokens, (T*)0, 0);
    }

    template<class T>
    typed_value<T>*
    value()
    {

        return boost::program_options::value<T>(0);
    }

    template<class T>
    typed_value<T>*
    value(T* v)
    {
        typed_value<T>* r = new typed_value<T>(v);

        return r;
    }

    template<class T>
    typed_value<T, wchar_t>*
    wvalue()
    {
        return wvalue<T>(0);
    }

    template<class T>
    typed_value<T, wchar_t>*
    wvalue(T* v)
    {
        typed_value<T, wchar_t>* r = new typed_value<T, wchar_t>(v);

        return r;
    }



}}
# 419 "/usr/include/boost/program_options/value_semantic.hpp" 2 3 4
# 14 "/usr/include/boost/program_options/options_description.hpp" 2 3 4

# 1 "/usr/include/boost/function.hpp" 1 3 4
# 64 "/usr/include/boost/function.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 65 "/usr/include/boost/function.hpp" 2 3 4
# 16 "/usr/include/boost/program_options/options_description.hpp" 2 3 4
# 35 "/usr/include/boost/program_options/options_description.hpp" 3 4
namespace boost {

namespace program_options {
# 47 "/usr/include/boost/program_options/options_description.hpp" 3 4
    class option_description {
    public:

        option_description();
# 76 "/usr/include/boost/program_options/options_description.hpp" 3 4
        option_description(const char* name,
                           const value_semantic* s);



        option_description(const char* name,
                           const value_semantic* s,
                           const char* description);

        virtual ~option_description();

        enum match_result { no_match, full_match, approximate_match };




        match_result match(const std::string& option, bool approx,
                           bool long_ignore_case, bool short_ignore_case) const;
# 103 "/usr/include/boost/program_options/options_description.hpp" 3 4
        const std::string& key(const std::string& option) const;
# 113 "/usr/include/boost/program_options/options_description.hpp" 3 4
        std::string canonical_display_name(int canonical_option_style = 0) const;

        const std::string& long_name() const;


        const std::string& description() const;


        shared_ptr<const value_semantic> semantic() const;


        std::string format_name() const;



        std::string format_parameter() const;

    private:

        option_description& set_name(const char* name);

        std::string m_short_name, m_long_name, m_description;


        shared_ptr<const value_semantic> m_value_semantic;
    };

    class options_description;



    class options_description_easy_init {
    public:
        options_description_easy_init(options_description* owner);

        options_description_easy_init&
        operator()(const char* name,
                   const char* description);

        options_description_easy_init&
        operator()(const char* name,
                   const value_semantic* s);

        options_description_easy_init&
        operator()(const char* name,
                   const value_semantic* s,
                   const char* description);

    private:
        options_description* owner;
    };
# 173 "/usr/include/boost/program_options/options_description.hpp" 3 4
    class options_description {
    public:
        static const unsigned m_default_line_length;


        options_description(unsigned line_length = m_default_line_length,
                            unsigned min_description_length = m_default_line_length / 2);







        options_description(const std::string& caption,
                            unsigned line_length = m_default_line_length,
                            unsigned min_description_length = m_default_line_length / 2);



        void add(shared_ptr<option_description> desc);






        options_description& add(const options_description& desc);

    public:






        options_description_easy_init add_options();

        const option_description& find(const std::string& name,
                                       bool approx,
                                       bool long_ignore_case = false,
                                       bool short_ignore_case = false) const;

        const option_description* find_nothrow(const std::string& name,
                                               bool approx,
                                               bool long_ignore_case = false,
                                               bool short_ignore_case = false) const;


        const std::vector< shared_ptr<option_description> >& options() const;




        friend std::ostream& operator<<(std::ostream& os,
                                             const options_description& desc);



        void print(std::ostream& os) const;

    private:
        typedef std::map<std::string, int>::const_iterator name2index_iterator;
        typedef std::pair<name2index_iterator, name2index_iterator>
            approximation_range;



        std::string m_caption;
        const unsigned m_line_length;
        const unsigned m_min_description_length;




        std::vector< shared_ptr<option_description> > m_options;







        std::vector<bool> belong_to_group;


        std::vector< shared_ptr<options_description> > groups;

    };


    class duplicate_option_error : public error {
    public:
        duplicate_option_error(const std::string& xwhat) : error(xwhat) {}
    };
}}
# 16 "/usr/include/boost/program_options.hpp" 2 3 4
# 1 "/usr/include/boost/program_options/positional_options.hpp" 1 3 4
# 19 "/usr/include/boost/program_options/positional_options.hpp" 3 4
namespace boost { namespace program_options {
# 36 "/usr/include/boost/program_options/positional_options.hpp" 3 4
    class positional_options_description {
    public:
        positional_options_description();






        positional_options_description&
        add(const char* name, int max_count);




        unsigned max_total_count() const;





        const std::string& name_for_position(unsigned position) const;

    private:



        std::vector<std::string> m_names;
        std::string m_trailing;
    };

}}
# 17 "/usr/include/boost/program_options.hpp" 2 3 4
# 1 "/usr/include/boost/program_options/parsers.hpp" 1 3 4
# 11 "/usr/include/boost/program_options/parsers.hpp" 3 4
# 1 "/usr/include/boost/program_options/option.hpp" 1 3 4
# 14 "/usr/include/boost/program_options/option.hpp" 3 4
namespace boost { namespace program_options {
# 23 "/usr/include/boost/program_options/option.hpp" 3 4
    template<class charT>
    class basic_option {
    public:
        basic_option()
        : position_key(-1)
        , unregistered(false)
        , case_insensitive(false)
        {}
        basic_option(const std::string& xstring_key,
               const std::vector< std::string> &xvalue)
        : string_key(xstring_key)
        , value(xvalue)
        , unregistered(false)
        , case_insensitive(false)
        {}



        std::string string_key;






        int position_key;

        std::vector< std::basic_string<charT> > value;


        std::vector< std::basic_string<charT> > original_tokens;





        bool unregistered;



        bool case_insensitive;
    };
    typedef basic_option<char> option;
    typedef basic_option<wchar_t> woption;

}}
# 12 "/usr/include/boost/program_options/parsers.hpp" 2 3 4
# 1 "/usr/include/boost/program_options/detail/cmdline.hpp" 1 3 4
# 12 "/usr/include/boost/program_options/detail/cmdline.hpp" 3 4
# 1 "/usr/include/boost/program_options/cmdline.hpp" 1 3 4
# 9 "/usr/include/boost/program_options/cmdline.hpp" 3 4
namespace boost { namespace program_options { namespace command_line_style {
# 26 "/usr/include/boost/program_options/cmdline.hpp" 3 4
    enum style_t {

        allow_long = 1,

        allow_short = allow_long << 1,

        allow_dash_for_short = allow_short << 1,

        allow_slash_for_short = allow_dash_for_short << 1,






        long_allow_adjacent = allow_slash_for_short << 1,


        long_allow_next = long_allow_adjacent << 1,


        short_allow_adjacent = long_allow_next << 1,


        short_allow_next = short_allow_adjacent << 1,







        allow_sticky = short_allow_next << 1,





        allow_guessing = allow_sticky << 1,


        long_case_insensitive = allow_guessing << 1,


        short_case_insensitive = long_case_insensitive << 1,


        case_insensitive = (long_case_insensitive | short_case_insensitive),



        allow_long_disguise = short_case_insensitive << 1,

        unix_style = (allow_short | short_allow_adjacent | short_allow_next
                      | allow_long | long_allow_adjacent | long_allow_next
                      | allow_sticky | allow_guessing
                      | allow_dash_for_short),

        default_style = unix_style
    };
}}}
# 13 "/usr/include/boost/program_options/detail/cmdline.hpp" 2 3 4







# 1 "/usr/include/boost/function.hpp" 1 3 4
# 64 "/usr/include/boost/function.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 25 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 27 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 47 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 48 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 83 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 88 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 93 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/usr/include/boost/function/detail/function_iterate.hpp" 1 3 4
# 14 "/usr/include/boost/function/detail/function_iterate.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 15 "/usr/include/boost/function/detail/function_iterate.hpp" 2 3 4
# 98 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 65 "/usr/include/boost/function.hpp" 2 3 4
# 21 "/usr/include/boost/program_options/detail/cmdline.hpp" 2 3 4
# 30 "/usr/include/boost/program_options/detail/cmdline.hpp" 3 4
namespace boost { namespace program_options { namespace detail {
# 59 "/usr/include/boost/program_options/detail/cmdline.hpp" 3 4
    class cmdline {
    public:

        typedef ::boost::program_options::command_line_style::style_t style_t;

        typedef function1<std::pair<std::string, std::string>,
                          const std::string&>
            additional_parser;

        typedef function1<std::vector<option>, std::vector<std::string>&>
            style_parser;
# 78 "/usr/include/boost/program_options/detail/cmdline.hpp" 3 4
        cmdline(const std::vector<std::string>& args);


        cmdline(int argc, const char*const * argv);

        void style(int style);
# 94 "/usr/include/boost/program_options/detail/cmdline.hpp" 3 4
        int get_canonical_option_prefix();

        void allow_unregistered();

        void set_options_description(const options_description& desc);
        void set_positional_options(
            const positional_options_description& m_positional);

        std::vector<option> run();

        std::vector<option> parse_long_option(std::vector<std::string>& args);
        std::vector<option> parse_short_option(std::vector<std::string>& args);
        std::vector<option> parse_dos_option(std::vector<std::string>& args);
        std::vector<option> parse_disguised_long_option(
            std::vector<std::string>& args);
        std::vector<option> parse_terminator(
            std::vector<std::string>& args);
        std::vector<option> handle_additional_parser(
            std::vector<std::string>& args);
# 123 "/usr/include/boost/program_options/detail/cmdline.hpp" 3 4
        void set_additional_parser(additional_parser p);

        void extra_style_parser(style_parser s);

        void check_style(int style) const;

        bool is_style_active(style_t style) const;

        void init(const std::vector<std::string>& args);

        void
        finish_option(option& opt,
                      std::vector<std::string>& other_tokens,
                      const std::vector<style_parser>& style_parsers);


        std::vector<std::string> args;
        style_t m_style;
        bool m_allow_unregistered;

        const options_description* m_desc;
        const positional_options_description* m_positional;

        additional_parser m_additional_parser;
        style_parser m_style_parser;
    };

    void test_cmdline_detail();

}}}
# 13 "/usr/include/boost/program_options/parsers.hpp" 2 3 4

# 1 "/usr/include/boost/function/function1.hpp" 1 3 4
# 11 "/usr/include/boost/function/function1.hpp" 3 4
# 1 "/usr/include/boost/function/detail/maybe_include.hpp" 1 3 4
# 12 "/usr/include/boost/function/function1.hpp" 2 3 4
# 15 "/usr/include/boost/program_options/parsers.hpp" 2 3 4
# 25 "/usr/include/boost/program_options/parsers.hpp" 3 4
namespace boost { namespace program_options {

    class options_description;
    class positional_options_description;







    template<class charT>
    class basic_parsed_options {
    public:
        explicit basic_parsed_options(const options_description* xdescription, int options_prefix = 0)
        : description(xdescription), m_options_prefix(options_prefix) {}

        std::vector< basic_option<charT> > options;





        const options_description* description;
# 59 "/usr/include/boost/program_options/parsers.hpp" 3 4
        int m_options_prefix;
    };





    template<>
    class basic_parsed_options<wchar_t> {
    public:

        explicit basic_parsed_options(const basic_parsed_options<char>& po);

        std::vector< basic_option<wchar_t> > options;
        const options_description* description;



        basic_parsed_options<char> utf8_encoded_options;
# 88 "/usr/include/boost/program_options/parsers.hpp" 3 4
        int m_options_prefix;
    };

    typedef basic_parsed_options<char> parsed_options;
    typedef basic_parsed_options<wchar_t> wparsed_options;





    typedef function1<std::pair<std::string, std::string>, const std::string&> ext_parser;
# 114 "/usr/include/boost/program_options/parsers.hpp" 3 4
    template<class charT>
    class basic_command_line_parser : private detail::cmdline {
    public:



        basic_command_line_parser(const std::vector<
                                  std::basic_string<charT> >& args);



        basic_command_line_parser(int argc, const charT* const argv[]);


        basic_command_line_parser& options(const options_description& desc);

        basic_command_line_parser& positional(
            const positional_options_description& desc);


        basic_command_line_parser& style(int);

        basic_command_line_parser& extra_parser(ext_parser);




        basic_parsed_options<charT> run();
# 151 "/usr/include/boost/program_options/parsers.hpp" 3 4
        basic_command_line_parser& allow_unregistered();

        using detail::cmdline::style_parser;

        basic_command_line_parser& extra_style_parser(style_parser s);

    private:
        const options_description* m_desc;
    };

    typedef basic_command_line_parser<char> command_line_parser;
    typedef basic_command_line_parser<wchar_t> wcommand_line_parser;




    template<class charT>
    basic_parsed_options<charT>
    parse_command_line(int argc, const charT* const argv[],
                       const options_description&,
                       int style = 0,
                       function1<std::pair<std::string, std::string>,
                                 const std::string&> ext
                       = ext_parser());





    template<class charT>

   

    basic_parsed_options<charT>
    parse_config_file(std::basic_istream<charT>&, const options_description&,
                      bool allow_unregistered = false);






    template<class charT>

   

    basic_parsed_options<charT>
    parse_config_file(const char* filename, const options_description&,
                      bool allow_unregistered = false);



    enum collect_unrecognized_mode
    { include_positional, exclude_positional };







    template<class charT>
    std::vector< std::basic_string<charT> >
    collect_unrecognized(const std::vector< basic_option<charT> >& options,
                         enum collect_unrecognized_mode mode);
# 226 "/usr/include/boost/program_options/parsers.hpp" 3 4
    parsed_options
    parse_environment(const options_description&,
                      const function1<std::string, std::string>& name_mapper);







    parsed_options
    parse_environment(const options_description&, const std::string& prefix);






    parsed_options
    parse_environment(const options_description&, const char* prefix);
# 254 "/usr/include/boost/program_options/parsers.hpp" 3 4
    std::vector<std::string>
    split_unix(const std::string& cmdline, const std::string& seperator = " \t",
         const std::string& quote = "'\"", const std::string& escape = "\\");



    std::vector<std::wstring>
    split_unix(const std::wstring& cmdline, const std::wstring& seperator = L" \t",
         const std::wstring& quote = L"'\"", const std::wstring& escape = L"\\");
# 283 "/usr/include/boost/program_options/parsers.hpp" 3 4
}}







# 1 "/usr/include/boost/program_options/detail/parsers.hpp" 1 3 4
# 9 "/usr/include/boost/program_options/detail/parsers.hpp" 3 4
# 1 "/usr/include/boost/program_options/detail/convert.hpp" 1 3 4
# 19 "/usr/include/boost/program_options/detail/convert.hpp" 3 4
# 1 "/usr/include/c++/4.8/cwchar" 1 3 4
# 39 "/usr/include/c++/4.8/cwchar" 3 4
       
# 40 "/usr/include/c++/4.8/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 45 "/usr/include/c++/4.8/cwchar" 2 3
# 20 "/usr/include/boost/program_options/detail/convert.hpp" 2 3 4
# 30 "/usr/include/boost/program_options/detail/convert.hpp" 3 4
namespace boost {



    std::wstring
    from_8_bit(const std::string& s,
               const std::codecvt<wchar_t, char, std::mbstate_t>& cvt);



    std::string
    to_8_bit(const std::wstring& s,
             const std::codecvt<wchar_t, char, std::mbstate_t>& cvt);




    std::wstring
    from_utf8(const std::string& s);


    std::string
    to_utf8(const std::wstring& s);



    std::string
    to_local_8_bit(const std::wstring& s);



    std::wstring
    from_local_8_bit(const std::string& s);

    namespace program_options
    {




        std::string to_internal(const std::string&);

        std::string to_internal(const std::wstring&);

        template<class T>
        std::vector<std::string> to_internal(const std::vector<T>& s)
        {
            std::vector<std::string> result;
            for (unsigned i = 0; i < s.size(); ++i)
                result.push_back(to_internal(s[i]));
            return result;
        }

    }



}
# 10 "/usr/include/boost/program_options/detail/parsers.hpp" 2 3 4



namespace boost { namespace program_options {

    namespace detail {
        template<class charT, class Iterator>
        std::vector<std::basic_string<charT> >
        make_vector(Iterator i, Iterator e)
        {
            std::vector<std::basic_string<charT> > result;


            for(; i != e; ++i)
                result.push_back(*i);
            return result;
        }
    }

    template<class charT>
    basic_command_line_parser<charT>::
    basic_command_line_parser(const std::vector<
                              std::basic_string<charT> >& xargs)
       : detail::cmdline(to_internal(xargs))
    {}


    template<class charT>
    basic_command_line_parser<charT>::
    basic_command_line_parser(int argc, const charT* const argv[])
    : detail::cmdline(


        to_internal(detail::make_vector<charT, const charT* const*>(argv+1, argv+argc+!argc)))
    {}


    template<class charT>
    basic_command_line_parser<charT>&
    basic_command_line_parser<charT>::options(const options_description& desc)
    {
       detail::cmdline::set_options_description(desc);
        m_desc = &desc;
        return *this;
    }

    template<class charT>
    basic_command_line_parser<charT>&
    basic_command_line_parser<charT>::positional(
        const positional_options_description& desc)
    {
        detail::cmdline::set_positional_options(desc);
        return *this;
    }

    template<class charT>
    basic_command_line_parser<charT>&
    basic_command_line_parser<charT>::style(int xstyle)
    {
        detail::cmdline::style(xstyle);
        return *this;
    }

    template<class charT>
    basic_command_line_parser<charT>&
    basic_command_line_parser<charT>::extra_parser(ext_parser ext)
    {
        detail::cmdline::set_additional_parser(ext);
        return *this;
    }

    template<class charT>
    basic_command_line_parser<charT>&
    basic_command_line_parser<charT>::allow_unregistered()
    {
        detail::cmdline::allow_unregistered();
        return *this;
    }

    template<class charT>
    basic_command_line_parser<charT>&
    basic_command_line_parser<charT>::extra_style_parser(style_parser s)
    {
        detail::cmdline::extra_style_parser(s);
        return *this;
    }



    template<class charT>
    basic_parsed_options<charT>
    basic_command_line_parser<charT>::run()
    {




        parsed_options result(m_desc, detail::cmdline::get_canonical_option_prefix());
        result.options = detail::cmdline::run();



        return basic_parsed_options<charT>(result);
    }


    template<class charT>
    basic_parsed_options<charT>
    parse_command_line(int argc, const charT* const argv[],
                       const options_description& desc,
                       int style,
                       function1<std::pair<std::string, std::string>,
                                 const std::string&> ext)
    {
        return basic_command_line_parser<charT>(argc, argv).options(desc).
            style(style).extra_parser(ext).run();
    }

    template<class charT>
    std::vector< std::basic_string<charT> >
    collect_unrecognized(const std::vector< basic_option<charT> >& options,
                         enum collect_unrecognized_mode mode)
    {
        std::vector< std::basic_string<charT> > result;
        for(unsigned i = 0; i < options.size(); ++i)
        {
            if (options[i].unregistered ||
                (mode == include_positional && options[i].position_key != -1))
            {
                copy(options[i].original_tokens.begin(),
                     options[i].original_tokens.end(),
                     back_inserter(result));
            }
        }
        return result;
    }


}}
# 292 "/usr/include/boost/program_options/parsers.hpp" 2 3 4
# 18 "/usr/include/boost/program_options.hpp" 2 3 4
# 1 "/usr/include/boost/program_options/variables_map.hpp" 1 3 4
# 24 "/usr/include/boost/program_options/variables_map.hpp" 3 4
namespace boost { namespace program_options {

    template<class charT>
    class basic_parsed_options;

    class value_semantic;
    class variables_map;







   
    void store(const basic_parsed_options<char>& options, variables_map& m,
                    bool utf8 = false);






   
    void store(const basic_parsed_options<wchar_t>& options,
                    variables_map& m);



    void notify(variables_map& m);




    class variable_value {
    public:
        variable_value() : m_defaulted(false) {}
        variable_value(const boost::any& xv, bool xdefaulted)
        : v(xv), m_defaulted(xdefaulted)
        {}



       template<class T>
       const T& as() const {
           return boost::any_cast<const T&>(v);
       }

       template<class T>
       T& as() {
           return boost::any_cast<T&>(v);
       }


        bool empty() const;


        bool defaulted() const;

        const boost::any& value() const;


        boost::any& value();
    private:
        boost::any v;
        bool m_defaulted;





        shared_ptr<const value_semantic> m_value_semantic;

        friend
        void store(const basic_parsed_options<char>& options,
              variables_map& m, bool);

        friend class variables_map;
    };



    class abstract_variables_map {
    public:
        abstract_variables_map();
        abstract_variables_map(const abstract_variables_map* next);

        virtual ~abstract_variables_map() {}
# 127 "/usr/include/boost/program_options/variables_map.hpp" 3 4
        const variable_value& operator[](const std::string& name) const;



        void next(abstract_variables_map* next);

    private:


        virtual const variable_value& get(const std::string& name) const = 0;

        const abstract_variables_map* m_next;
    };






    class variables_map : public abstract_variables_map,
                               public std::map<std::string, variable_value>
    {
    public:
        variables_map();
        variables_map(const abstract_variables_map* next);


        const variable_value& operator[](const std::string& name) const
        { return abstract_variables_map::operator[](name); }


        void clear();

        void notify();

    private:


        const variable_value& get(const std::string& name) const;



        std::set<std::string> m_final;

        friend
        void store(const basic_parsed_options<char>& options,
                          variables_map& xm,
                          bool utf8);





        std::map<std::string, std::string> m_required;
    };






    inline bool
    variable_value::empty() const
    {
        return v.empty();
    }

    inline bool
    variable_value::defaulted() const
    {
        return m_defaulted;
    }

    inline
    const boost::any&
    variable_value::value() const
    {
        return v;
    }

    inline
    boost::any&
    variable_value::value()
    {
        return v;
    }

}}
# 19 "/usr/include/boost/program_options.hpp" 2 3 4




# 1 "/usr/include/boost/program_options/version.hpp" 1 3 4
# 24 "/usr/include/boost/program_options.hpp" 2 3 4
# 24 "./drizzled/constrained_value.h" 2




namespace drizzled
{




class invalid_option_value :
  public boost::exception,
  public boost::program_options::invalid_option_value
{
public:
  invalid_option_value(const std::string &option_value) :
    boost::exception(),
    boost::program_options::invalid_option_value(option_value)
  {}
};

template<class T> class constrained_value;
template<class T>
std::istream& operator>>(std::istream& is, constrained_value<T>& bound_val);
template<class T>
std::ostream& operator<<(std::ostream& os, const constrained_value<T>& v);

template<class T>
class constrained_value
{
  T m_val;
protected:

  virtual constrained_value<T>& set_value(const constrained_value<T>& rhs)= 0;
  virtual constrained_value<T>& set_value(T rhs)= 0;

public:
  explicit constrained_value<T>(T in_value= 0) :
    m_val(in_value)
  { }

  virtual ~constrained_value<T>()
  {}

  operator T() const
  {
    return m_val;
  }

  constrained_value<T>& operator=(const constrained_value<T>& rhs)
  {
    return set_value(rhs);
  }

  constrained_value<T>& operator=(T rhs)
  {
    return set_value(rhs);
  }

  T get() const
  {
    return m_val;
  }

  void setVal(T in_val)
  {
    m_val= in_val;
  }

  friend std::istream&
  operator>>(std::istream& is,
             constrained_value<T>& bound_val)
  {
    T inner_val;
    is >> inner_val;
    bound_val= inner_val;
    return is;
  }

  friend
  std::ostream& operator<<(std::ostream& os, const constrained_value<T>& v)
  {
    os << v.get();
    return os;
  }
};

namespace
{
template<class T, T min_val>
bool less_than_min(T val_to_check)
{
  return val_to_check < min_val;
}

template<>
inline bool less_than_min<uint16_t, 0>(uint16_t)
{
  return false;
}

template<>
inline bool less_than_min<uint32_t, 0>(uint32_t)
{
  return false;
}

template<>
inline bool less_than_min<uint64_t, 0>(uint64_t)
{
  return false;
}

template<class T, T min_val>
bool greater_than_max(T val_to_check)
{
  return val_to_check > min_val;
}

template<>
inline bool greater_than_max<uint16_t, (65535)>(uint16_t)
{
  return false;
}

template<>
inline bool greater_than_max<uint32_t, (4294967295U)>(uint32_t)
{
  return false;
}

template<>
inline bool greater_than_max<uint64_t, (18446744073709551615ULL)>(uint64_t)
{
  return false;
}
}

typedef boost::error_info<struct tag_invalid_max,uint64_t> invalid_max_info;
typedef boost::error_info<struct tag_invalid_min,int64_t> invalid_min_info;
typedef boost::error_info<struct tag_invalid_min,std::string> invalid_value;

template<class T,
  T MAXVAL,
  T MINVAL, unsigned int ALIGN= 1>
class constrained_check :
  public constrained_value<T>
{
public:
  constrained_check<T,MAXVAL,MINVAL,ALIGN>(T in_value= 0) :
    constrained_value<T>(in_value)
  { }

protected:
  constrained_value<T>& set_value(const constrained_value<T>& rhs)
  {
    return set_value(rhs.get());
  }

  constrained_value<T>& set_value(T rhs)
  {
    if (greater_than_max<T,MAXVAL>(rhs))
    {
      boost::throw_exception(invalid_option_value(boost::lexical_cast<std::string>(rhs)) << invalid_max_info(static_cast<uint64_t>(MAXVAL)));
    }

    if (less_than_min<T,MINVAL>(rhs))
    {
      boost::throw_exception(invalid_option_value(boost::lexical_cast<std::string>(rhs)) << invalid_min_info(static_cast<int64_t>(MINVAL)));
    }
    rhs-= rhs % ALIGN;
    this->setVal(rhs);
    return *this;
  }


};

typedef constrained_check<uint64_t, (18446744073709551615ULL), 0> uint64_constraint;
typedef constrained_check<uint32_t, (4294967295U), 0> uint32_constraint;
typedef constrained_check<uint64_t, (18446744073709551615ULL), 1> uint64_nonzero_constraint;
typedef constrained_check<uint32_t, (4294967295U), 1> uint32_nonzero_constraint;
typedef drizzled::constrained_check<in_port_t, 65535, 0> port_constraint;

typedef constrained_check<uint32_t,65535,1> back_log_constraints;

}

template<class T>
void validate(boost::any& v,
              const std::vector<std::string>& values,
              drizzled::constrained_value<T> val, int)
{
  boost::program_options::validators::check_first_occurrence(v);
  const std::string& s= boost::program_options::validators::get_single_string(values);

  val= boost::lexical_cast<T>(s);
  v= boost::any(val);
}
# 27 "./drizzled/sys_var.h" 2
# 1 "./drizzled/set_var.h" 1
# 20 "./drizzled/set_var.h"
       







namespace drizzled {
# 42 "./drizzled/set_var.h"
class set_var_base
{
public:
  virtual ~set_var_base() {}
  virtual int check(Session*)= 0;
  virtual int update(Session*)= 0;

};


class set_var : public set_var_base
{
  uint64_t uint64_t_value;
  std::string str_value;
public:
  sys_var *var;
  Item *value;
  sql_var_t type;
  str_ref base;

  set_var(sql_var_t type_arg, sys_var *var_arg, str_ref base_name_arg, Item *value_arg);
  int check(Session *session);
  int update(Session *session);
  void setValue(const std::string &new_value);
  void setValue(uint64_t new_value);
  void updateValue();

  uint64_t getInteger()
  {
    return uint64_t_value;
  }

};



class set_var_user: public set_var_base
{
  Item_func_set_user_var *user_var_item;
public:
  explicit set_var_user(Item_func_set_user_var *item) :
    user_var_item(item)
  {}
  int check(Session *session);
  int update(Session *session);
};

typedef boost::shared_ptr<set_var_base> SetVarPtr;
typedef std::vector<SetVarPtr> SetVarVector;
int sql_set_variables(Session *session, const SetVarVector &var_list);

}
# 28 "./drizzled/sys_var.h" 2
# 1 "./drizzled/show_type.h" 1
# 20 "./drizzled/show_type.h"
       

namespace drizzled
{




typedef enum enum_drizzle_show_type
{
  SHOW_UNDEF, SHOW_BOOL, SHOW_INT, SHOW_LONG,
  SHOW_LONGLONG, SHOW_CHAR, SHOW_CHAR_PTR,
  SHOW_FUNC,
  SHOW_LONG_STATUS, SHOW_DOUBLE_STATUS,
  SHOW_MY_BOOL, SHOW_HA_ROWS, SHOW_SYS, SHOW_INT_NOFLUSH,
  SHOW_LONGLONG_STATUS, SHOW_DOUBLE, SHOW_SIZE
} SHOW_TYPE;

struct drizzle_show_var {
  const char *name;
  char *value;
  SHOW_TYPE type;
};


static const int SHOW_VAR_FUNC_BUFF_SIZE= 1024;
typedef int (*drizzle_show_var_func)(drizzle_show_var *, char *);

struct st_show_var_func_container
{
  drizzle_show_var_func func;
};

}
# 29 "./drizzled/sys_var.h" 2






namespace drizzled {

typedef int (*sys_check_func)(Session *, set_var *);
typedef bool (*sys_update_func)(Session *, set_var *);
typedef void (*sys_after_update_func)(Session *, sql_var_t);
typedef void (*sys_set_default_func)(Session *, sql_var_t);
typedef unsigned char *(*sys_value_ptr_func)(Session *session);

static const std::vector<std::string> empty_aliases;
extern struct drizzle_system_variables max_system_variables;
extern size_t table_def_size;

extern std::string drizzle_tmpdir;
extern const char *first_keyword;
extern const char *in_left_expr_name;
extern const char *in_additional_cond;
extern const char *in_having_cond;
extern boost::filesystem::path basedir;
extern boost::filesystem::path pid_file;
extern boost::filesystem::path secure_file_priv;
extern uint64_t session_startup_options;
extern uint32_t global_thread_id;
extern uint64_t table_cache_size;
extern back_log_constraints back_log;
extern uint32_t ha_open_options;
extern const char *drizzled_bind_host;
extern uint32_t dropping_tables;
extern bool opt_endinfo;
extern uint32_t volatile thread_running;
extern uint32_t volatile global_read_lock;
extern bool opt_readonly;
extern const char *opt_scheduler;
extern size_t transaction_message_threshold;

uint64_t fix_unsigned(Session*, uint64_t, const option&);

__attribute__ ((visibility("default"))) const std::string &getServerHostname();
int sys_var_init();





class __attribute__ ((visibility("default"))) sys_var
{
protected:
  std::string name;
  sys_check_func check_func;
  sys_after_update_func after_update;
  struct option *option_limits;
  bool m_allow_empty_value;
public:
  sys_var(const std::string &name_arg,
          sys_after_update_func func= __null,
          sys_check_func check_func_arg= __null)
    :
    name(name_arg),
    check_func(check_func_arg),
    after_update(func),
    option_limits(__null),
    m_allow_empty_value(true)
  {}
  virtual ~sys_var() {}

  void setName(const std::string &name_in)
  {
    name= name_in;
  }
# 111 "./drizzled/sys_var.h"
  inline const std::string &getName() const
  {
    return name;
  }




  const std::vector<std::string>& getAliases() const
  {
    return empty_aliases;
  }



  inline struct option *getOptionLimits() const
  {
    return option_limits;
  }





  inline void setOptionLimits(struct option *in_option_limits)
  {
    option_limits= in_option_limits;
  }



  inline sys_after_update_func getAfterUpdateTrigger() const
  {
    return after_update;
  }
  virtual bool check(Session *session, set_var *var);
  bool check_enum(Session *session, set_var *var, const TYPELIB *enum_names);
  virtual bool update(Session *session, set_var *var)=0;
  virtual void set_default(Session *, sql_var_t)
  {}
  virtual SHOW_TYPE show_type()
  {
    return SHOW_UNDEF;
  }
  virtual unsigned char *value_ptr(Session*, sql_var_t) = 0;
  virtual bool check_type(sql_var_t type)
  {
    return type != OPT_GLOBAL;
  }
  virtual bool check_update_type(Item_result type)
  {
    return type != INT_RESULT;
  }
  virtual bool check_default(sql_var_t)
  {
    return option_limits == 0;
  }
  Item *item(Session*, sql_var_t);
  virtual bool is_readonly() const
  {
    return 0;
  }
};





class __attribute__ ((visibility("default"))) sys_var_global : public sys_var
{
protected:
  pthread_mutex_t *guard;
public:
  sys_var_global(const char *name_arg, sys_after_update_func after_update_arg, pthread_mutex_t *guard_arg) :
    sys_var(name_arg, after_update_arg),
    guard(guard_arg)
  {}
};

class __attribute__ ((visibility("default"))) sys_var_uint32_t_ptr : public sys_var
{
  uint32_t *value;
public:
  sys_var_uint32_t_ptr(const char *name_arg, uint32_t *value_ptr_arg) :
    sys_var(name_arg), value(value_ptr_arg)
  { }
  sys_var_uint32_t_ptr(const char *name_arg, uint32_t *value_ptr_arg, sys_after_update_func func) :
    sys_var(name_arg,func), value(value_ptr_arg)
  { }
  bool check(Session *session, set_var *var);
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_INT; }
  unsigned char *value_ptr(Session *, sql_var_t)
  { return (unsigned char*) value; }
};

class __attribute__ ((visibility("default"))) sys_var_uint32_t_ptr_readonly : public sys_var_uint32_t_ptr
{
public:
  sys_var_uint32_t_ptr_readonly(const char *name_arg, uint32_t *value_ptr_arg) :
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg)
  {}

  sys_var_uint32_t_ptr_readonly(const char *name_arg,
                                uint32_t *value_ptr_arg,
                                sys_after_update_func func) :
    sys_var_uint32_t_ptr(name_arg, value_ptr_arg, func)
  {}

  bool is_readonly() const
  {
    return true;
  }
};


class __attribute__ ((visibility("default"))) sys_var_uint64_t_ptr : public sys_var
{
  uint64_t *value;
  const uint64_t default_value;
  bool have_default_value;
public:
  sys_var_uint64_t_ptr(const char *name_arg, uint64_t *value_ptr_arg) :
    sys_var(name_arg),
    value(value_ptr_arg),
    default_value(0),
    have_default_value(false)
  { }

  sys_var_uint64_t_ptr(const char *name_arg,
                       uint64_t *value_ptr_arg,
                       const uint64_t default_value_in) :
    sys_var(name_arg),
    value(value_ptr_arg),
    default_value(default_value_in),
    have_default_value(true)
  { }

  sys_var_uint64_t_ptr(const char *name_arg,
                       uint64_t *value_ptr_arg,
                       sys_after_update_func func) :
    sys_var(name_arg,func),
    value(value_ptr_arg),
    default_value(0),
    have_default_value(false)
  { }

  sys_var_uint64_t_ptr(const char *name_arg,
                       uint64_t *value_ptr_arg,
                       sys_after_update_func func,
                       const uint64_t default_value_in) :
    sys_var(name_arg,func),
    value(value_ptr_arg),
    default_value(default_value_in),
    have_default_value(true)
  { }

  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  virtual bool check_default(sql_var_t)
  {
    return (not have_default_value) && option_limits == 0;
  }
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
  unsigned char *value_ptr(Session *, sql_var_t)
  { return (unsigned char*) value; }
};

class __attribute__ ((visibility("default"))) sys_var_size_t_ptr :public sys_var
{
  size_t *value;
public:
  sys_var_size_t_ptr(const char *name_arg, size_t *value_ptr_arg)
    :sys_var(name_arg),value(value_ptr_arg)
  { }
  sys_var_size_t_ptr(const char *name_arg, size_t *value_ptr_arg,
                     sys_after_update_func func)
    :sys_var(name_arg,func), value(value_ptr_arg)
  { }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_SIZE; }
  unsigned char *value_ptr(Session *, sql_var_t)
  { return (unsigned char*) value; }
};

class __attribute__ ((visibility("default"))) sys_var_size_t_ptr_readonly :public sys_var_size_t_ptr
{
public:
  sys_var_size_t_ptr_readonly(const char *name_arg,
                            size_t *value_arg)
    :sys_var_size_t_ptr(name_arg, value_arg)
  {}
  bool is_readonly() const { return 1; }
};

class __attribute__ ((visibility("default"))) sys_var_bool_ptr :public sys_var
{
  bool default_value;
public:
  bool *value;
  sys_var_bool_ptr(const std::string &name_arg, bool *value_arg,
                   sys_after_update_func func= __null) :
    sys_var(name_arg, func), default_value(*value_arg), value(value_arg)
  { }
  bool check(Session *session, set_var *var);
  virtual bool check_default(sql_var_t)
  {
    return false;
  }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
  unsigned char *value_ptr(Session *, sql_var_t)
  { return (unsigned char*) value; }
  bool check_update_type(Item_result)
  { return 0; }
};

class __attribute__ ((visibility("default"))) sys_var_bool_ptr_readonly :public sys_var_bool_ptr
{
public:
  sys_var_bool_ptr_readonly(const char *name_arg,
                            bool *value_arg)
    :sys_var_bool_ptr(name_arg, value_arg)
  {}
  bool is_readonly() const { return 1; }
};


class __attribute__ ((visibility("default"))) sys_var_str :public sys_var
{
public:
  char *value;
  uint32_t value_length;
  sys_update_func update_func;
  sys_set_default_func set_default_func;
  sys_var_str(const char *name_arg,
              sys_check_func check_func_arg,
              sys_update_func update_func_arg,
              sys_set_default_func set_default_func_arg,
              char *value_arg) :
    sys_var(name_arg, __null, check_func_arg),
    value(value_arg),
    update_func(update_func_arg),
    set_default_func(set_default_func_arg)
  { }
  bool check(Session *session, set_var *var);
  bool update(Session *session, set_var *var)
  {
    return (*update_func)(session, var);
  }
  void set_default(Session *session, sql_var_t type)
  {
    (*set_default_func)(session, type);
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  { return (unsigned char*) value; }
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;
  }
  bool check_default(sql_var_t)
  { return 0; }
};


class __attribute__ ((visibility("default"))) sys_var_fs_path :
  public sys_var
{
  const boost::filesystem::path &value;
public:
  sys_var_fs_path(const char *name_arg,
                  const boost::filesystem::path& value_arg) :
    sys_var(name_arg),
    value(value_arg)
  { }

  inline void set(char *)
  { }

  bool check(Session *, set_var *)
  {
    return true;
  }
  bool update(Session *, set_var *)
  {
    return true;
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  {
    return (unsigned char*)(value.file_string().c_str());
  }
  bool check_update_type(Item_result)
  {
    return true;
  }
  bool check_default(sql_var_t) { return true; }
  bool is_readonly() const { return true; }
};

template<class T>
class sys_var_constrained_value :
  public sys_var
{
  constrained_value<T> &value;
  T basic_value;
  T default_value;
public:
  sys_var_constrained_value(const char *name_arg,
                            constrained_value<T> &value_arg) :
    sys_var(name_arg),
    value(value_arg),
    default_value(value_arg.get())
  { }

  sys_var_constrained_value(const char *name_arg,
                            constrained_value<T> &value_arg,
                            sys_after_update_func after_update_func_arg) :
    sys_var(name_arg, after_update_func_arg),
    value(value_arg),
    default_value(value_arg.get())
  { }

  sys_var_constrained_value(const char *name_arg,
                            constrained_value<T> &value_arg,
                            sys_check_func check_func_arg) :
    sys_var(name_arg, __null, check_func_arg),
    value(value_arg),
    default_value(value_arg.get())
  { }

public:
  bool is_readonly() const
  {
    return false;
  }

  SHOW_TYPE show_type() { return SHOW_INT; }

  bool update(Session *, set_var *var)
  {
    value= uint32_t(var->getInteger());
    return false;
  }

  bool check_default(sql_var_t)
  {
    return false;
  }

  void set_default(Session *, sql_var_t)
  {
    value= default_value;
  }

  unsigned char *value_ptr(Session *, sql_var_t)
  {
    basic_value= value.get();
    return (unsigned char*)&basic_value;
  }
};

template<>
inline SHOW_TYPE sys_var_constrained_value<uint64_t>::show_type()
{
  return SHOW_LONGLONG;
}

template<>
inline SHOW_TYPE sys_var_constrained_value<int64_t>::show_type()
{
  return SHOW_LONGLONG;
}

template<>
inline SHOW_TYPE sys_var_constrained_value<uint32_t>::show_type()
{
  return SHOW_INT;
}

template<>
inline SHOW_TYPE sys_var_constrained_value<int32_t>::show_type()
{
  return SHOW_LONG;
}

template<>
inline bool sys_var_constrained_value<uint64_t>::update(Session *, set_var *var)
{
  value= var->getInteger();
  return false;
}

template<>
inline bool sys_var_constrained_value<uint32_t>::update(Session *, set_var *var)
{
  value= uint32_t(var->getInteger());
  return false;
}

template<class T>
class sys_var_constrained_value_readonly :
  public sys_var_constrained_value<T>
{
public:
  sys_var_constrained_value_readonly(const char *name_arg,
                                     constrained_value<T> &value_arg) :
    sys_var_constrained_value<T>(name_arg, value_arg)
  { }

  sys_var_constrained_value_readonly(const char *name_arg,
                                     constrained_value<T> &value_arg,
                                     T default_value_arg) :
    sys_var_constrained_value<T>(name_arg, value_arg, default_value_arg)
  { }

public:
  bool is_readonly() const
  {
    return true;
  }
};

class __attribute__ ((visibility("default"))) sys_var_std_string :
  public sys_var
{
  std::string &value;
  sys_check_func check_func;
  sys_update_func update_func;
  sys_set_default_func set_default_func;
public:
  sys_var_std_string(const std::string &name_arg,
                     std::string &value_arg,
                     sys_check_func check_func_arg= __null,
                     sys_update_func update_func_arg= __null) :
    sys_var(name_arg),
    value(value_arg),
    check_func(check_func_arg),
    update_func(update_func_arg)
  { }

  inline void set(char *val_in)
  {
    value= val_in;
  }

  void set_check_func(sys_check_func check_func_arg= __null)
  {
    check_func= check_func_arg;
  }

  void set_update_func(sys_update_func update_func_arg= __null)
  {
    update_func= update_func_arg;
  }

  bool check(Session *session, set_var *var);

  bool update(Session *session, set_var *var)
  {
    if (update_func != __null)
    {
      return (*update_func)(session, var);
    }
    return false;
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  {
    return (unsigned char*)(value.c_str());
  }
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;
  }
  bool check_default(sql_var_t)
  { return true; }
  bool is_readonly() const { return false; }
};

class __attribute__ ((visibility("default"))) sys_var_const_string :
  public sys_var
{
  const std::string &value;
public:
  sys_var_const_string(const char *name_arg,
                       const std::string& value_arg) :
    sys_var(name_arg),
    value(value_arg)
  { }

  inline void set(char *)
  { }

  bool check(Session *, set_var *)
  {
    return true;
  }
  bool update(Session *, set_var *)
  {
    return true;
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  {
    return (unsigned char*)(value.c_str());
  }
  bool check_update_type(Item_result)
  {
    return true;
  }
  bool check_default(sql_var_t) { return true; }
  bool is_readonly() const { return true; }
};

class __attribute__ ((visibility("default"))) sys_var_const_string_val :
  public sys_var
{
  const std::string value;
public:
  sys_var_const_string_val(const char *name_arg,
                           const std::string& value_arg) :
    sys_var(name_arg),
    value(value_arg)
  { }

  inline void set(char *)
  { }

  bool check(Session *, set_var *)
  {
    return true;
  }
  bool update(Session *, set_var *)
  {
    return true;
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  {
    return (unsigned char*)(value.c_str());
  }
  bool check_update_type(Item_result)
  {
    return true;
  }
  bool check_default(sql_var_t) { return true; }
  bool is_readonly() const { return true; }
};

class __attribute__ ((visibility("default"))) sys_var_const_str :public sys_var
{
  char *value;
public:
  sys_var_const_str(const char *name_arg,
                    const char *value_arg)
    :sys_var(name_arg), value((char*) value_arg)
  { }
  inline void set (char *new_value)
  {
    value= new_value;
  }
  bool check(Session *, set_var *)
  {
    return 1;
  }
  bool update(Session *, set_var *)
  {
    return 1;
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  {
    return (unsigned char*) value;
  }
  bool check_update_type(Item_result)
  {
    return 1;
  }
  bool check_default(sql_var_t)
  { return 1; }
  bool is_readonly() const { return 1; }
};


class __attribute__ ((visibility("default"))) sys_var_const_str_ptr :public sys_var
{
  char **value;
public:
  sys_var_const_str_ptr(const char *name_arg, char **value_arg)
    :sys_var(name_arg),value(value_arg)
  { }
  bool check(Session *, set_var *)
  {
    return 1;
  }
  bool update(Session *, set_var *)
  {
    return 1;
  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *, sql_var_t)
  {
    return (unsigned char*) *value;
  }
  bool check_update_type(Item_result)
  {
    return 1;
  }
  bool check_default(sql_var_t)
  { return 1; }
  bool is_readonly(void) const { return 1; }
};


class __attribute__ ((visibility("default"))) sys_var_session :public sys_var
{
public:
  sys_var_session(const char *name_arg,
              sys_after_update_func func= __null)
    :sys_var(name_arg, func)
  {}
  bool check_type(sql_var_t)
  { return 0; }
  bool check_default(sql_var_t type)
  {
    return type == OPT_GLOBAL && !option_limits;
  }
};

class __attribute__ ((visibility("default"))) sys_var_session_uint32_t :public sys_var_session
{
  sys_check_func check_func;
public:
  uint32_t drizzle_system_variables::*offset;
  sys_var_session_uint32_t(const char *name_arg,
                           uint32_t drizzle_system_variables::*offset_arg,
                           sys_check_func c_func= __null,
                           sys_after_update_func au_func= __null)
    :sys_var_session(name_arg, au_func), check_func(c_func),
    offset(offset_arg)
  { }
  bool check(Session *session, set_var *var);
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_INT; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
};


class __attribute__ ((visibility("default"))) sys_var_session_ha_rows :public sys_var_session
{
public:
  ha_rows drizzle_system_variables::*offset;
  sys_var_session_ha_rows(const char *name_arg,
                      ha_rows drizzle_system_variables::*offset_arg)
    :sys_var_session(name_arg), offset(offset_arg)
  { }
  sys_var_session_ha_rows(const char *name_arg,
                      ha_rows drizzle_system_variables::*offset_arg,
        sys_after_update_func func)
    :sys_var_session(name_arg,func), offset(offset_arg)
  { }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_HA_ROWS; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
};


class __attribute__ ((visibility("default"))) sys_var_session_uint64_t :public sys_var_session
{
  sys_check_func check_func;
public:
  uint64_t drizzle_system_variables::*offset;
  bool only_global;
  sys_var_session_uint64_t(
                           const char *name_arg,
                           uint64_t drizzle_system_variables::*offset_arg,
                           sys_after_update_func au_func= __null,
                           sys_check_func c_func= __null)
    :sys_var_session(name_arg, au_func),
    check_func(c_func),
    offset(offset_arg)
  { }
  sys_var_session_uint64_t(const char *name_arg,
                           uint64_t drizzle_system_variables::*offset_arg,
                           sys_after_update_func func,
                           bool only_global_arg,
                           sys_check_func cfunc= __null)
    :sys_var_session(name_arg, func),
    check_func(cfunc),
    offset(offset_arg),
    only_global(only_global_arg)
  { }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
  bool check(Session *session, set_var *var);
  bool check_default(sql_var_t type)
  {
    return type == OPT_GLOBAL && !option_limits;
  }
  bool check_type(sql_var_t type)
  {
    return (only_global && type != OPT_GLOBAL);
  }
};

class __attribute__ ((visibility("default"))) sys_var_session_size_t :public sys_var_session
{
  sys_check_func check_func;
public:
  size_t drizzle_system_variables::*offset;
  bool only_global;
  sys_var_session_size_t(const char *name_arg,
                         size_t drizzle_system_variables::*offset_arg,
                         sys_after_update_func au_func= __null,
                         sys_check_func c_func= __null)
    :sys_var_session(name_arg, au_func),
     check_func(c_func),
     offset(offset_arg)
  { }
  sys_var_session_size_t(const char *name_arg,
                         size_t drizzle_system_variables::*offset_arg,
                         sys_after_update_func func,
                         bool only_global_arg,
                         sys_check_func cfunc= __null)
    :sys_var_session(name_arg, func),
     check_func(cfunc),
     offset(offset_arg),
     only_global(only_global_arg)
  { }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_SIZE; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
  bool check(Session *session, set_var *var);
  bool check_default(sql_var_t type)
  {
    return type == OPT_GLOBAL && !option_limits;
  }
  bool check_type(sql_var_t type)
  {
    return (only_global && type != OPT_GLOBAL);
  }
};


class __attribute__ ((visibility("default"))) sys_var_session_bool :public sys_var_session
{
public:
  bool drizzle_system_variables::*offset;
  sys_var_session_bool(const char *name_arg, bool drizzle_system_variables::*offset_arg)
    :sys_var_session(name_arg), offset(offset_arg)
  { }
  sys_var_session_bool(const char *name_arg, bool drizzle_system_variables::*offset_arg,
     sys_after_update_func func)
    :sys_var_session(name_arg,func), offset(offset_arg)
  { }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
  bool check(Session *session, set_var *var);
  bool check_update_type(Item_result)
  { return 0; }
};


class __attribute__ ((visibility("default"))) sys_var_session_enum :public sys_var_session
{
protected:
  uint32_t drizzle_system_variables::*offset;
  TYPELIB *enum_names;
  sys_check_func check_func;
public:
  sys_var_session_enum(const char *name_arg,
                   uint32_t drizzle_system_variables::*offset_arg, TYPELIB *typelib,
                   sys_after_update_func func= __null,
                   sys_check_func check_f= __null)
    :sys_var_session(name_arg, func), offset(offset_arg),
    enum_names(typelib), check_func(check_f)
  { }
  bool check(Session *session, set_var *var)
  {
    int ret= 0;
    if (check_func)
      ret= (*check_func)(session, var);
    return ret ? ret : check_enum(session, var, enum_names);
  }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
  bool check_update_type(Item_result)
  { return 0; }
};


class __attribute__ ((visibility("default"))) sys_var_session_storage_engine :public sys_var_session
{
protected:
  plugin::StorageEngine *drizzle_system_variables::*offset;
public:
  sys_var_session_storage_engine(const char *name_arg,
                                 plugin::StorageEngine *drizzle_system_variables::*offset_arg)
    :sys_var_session(name_arg), offset(offset_arg)
  { }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  bool check_update_type(Item_result type)
  {
    return type != STRING_RESULT;
  }
  void set_default(Session *session, sql_var_t type);
  bool update(Session *session, set_var *var);
  unsigned char *value_ptr(Session *session, sql_var_t type);
};

class __attribute__ ((visibility("default"))) sys_var_session_bit :public sys_var_session
{
  sys_check_func check_func;
  sys_update_func update_func;
public:
  uint64_t bit_flag;
  bool reverse;
  sys_var_session_bit(const char *name_arg,
                  sys_check_func c_func, sys_update_func u_func,
                  uint64_t bit, bool reverse_arg=0)
    :sys_var_session(name_arg, __null), check_func(c_func),
    update_func(u_func), bit_flag(bit), reverse(reverse_arg)
  { }
  bool check(Session *session, set_var *var);
  bool update(Session *session, set_var *var);
  bool check_update_type(Item_result)
  { return 0; }
  bool check_type(sql_var_t type) { return type == OPT_GLOBAL; }
  SHOW_TYPE show_type() { return SHOW_MY_BOOL; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
};



class __attribute__ ((visibility("default"))) sys_var_timestamp :public sys_var
{
public:
  sys_var_timestamp(const char *name_arg)
    :sys_var(name_arg, __null)
  { }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  bool check_type(sql_var_t type) { return type == OPT_GLOBAL; }
  bool check_default(sql_var_t)
  { return 0; }
  SHOW_TYPE show_type(void) { return SHOW_LONG; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
};


class __attribute__ ((visibility("default"))) sys_var_last_insert_id :public sys_var
{
public:
  sys_var_last_insert_id(const char *name_arg)
    :sys_var(name_arg, __null)
  { }
  bool update(Session *session, set_var *var);
  bool check_type(sql_var_t type) { return type == OPT_GLOBAL; }
  SHOW_TYPE show_type() { return SHOW_LONGLONG; }
  unsigned char *value_ptr(Session *session, sql_var_t type);
};


class __attribute__ ((visibility("default"))) sys_var_collation :public sys_var_session
{
public:
  sys_var_collation(const char *name_arg)
    :sys_var_session(name_arg, __null)
  { }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  bool check_update_type(Item_result type)
  {
    return ((type != STRING_RESULT) && (type != INT_RESULT));
  }
  bool check_default(sql_var_t) { return 0; }
  virtual void set_default(Session *session, sql_var_t type)= 0;
};

class __attribute__ ((visibility("default"))) sys_var_collation_sv :public sys_var_collation
{
  const charset_info_st *drizzle_system_variables::*offset;
  const charset_info_st **global_default;
public:
  sys_var_collation_sv(const char *name_arg,
                       const charset_info_st *drizzle_system_variables::*offset_arg,
                       const charset_info_st **global_default_arg)
    :sys_var_collation(name_arg),
    offset(offset_arg), global_default(global_default_arg)
  {

  }
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  unsigned char *value_ptr(Session *session, sql_var_t type);
};



class __attribute__ ((visibility("default"))) sys_var_readonly: public sys_var
{
public:
  sql_var_t var_type;
  SHOW_TYPE show_type_value;
  sys_value_ptr_func value_ptr_func;
  sys_var_readonly(const char *name_arg, sql_var_t type,
     SHOW_TYPE show_type_arg,
     sys_value_ptr_func value_ptr_func_arg)
    :sys_var(name_arg), var_type(type),
       show_type_value(show_type_arg), value_ptr_func(value_ptr_func_arg)
  { }
  bool update(Session *, set_var *)
  { return 1; }
  bool check_default(sql_var_t)
  { return 1; }
  bool check_type(sql_var_t type) { return type != var_type; }
  bool check_update_type(Item_result)
  { return 1; }
  unsigned char *value_ptr(Session *session, sql_var_t)
  {
    return (*value_ptr_func)(session);
  }
  SHOW_TYPE show_type(void) { return show_type_value; }
  bool is_readonly(void) const { return 1; }
};

class __attribute__ ((visibility("default"))) sys_var_microseconds :public sys_var_session
{
  uint64_t drizzle_system_variables::*offset;
public:
  sys_var_microseconds(const char *name_arg,
                       uint64_t drizzle_system_variables::*offset_arg):
    sys_var_session(name_arg), offset(offset_arg)
  { }
  bool check(Session *, set_var *) {return 0;}
  bool update(Session *session, set_var *var);
  void set_default(Session *session, sql_var_t type);
  SHOW_TYPE show_type() { return SHOW_DOUBLE; }
  bool check_update_type(Item_result type)
  {
    return (type != INT_RESULT && type != REAL_RESULT && type != DECIMAL_RESULT);
  }
};

class __attribute__ ((visibility("default"))) sys_var_session_lc_time_names :public sys_var_session
{
public:
  sys_var_session_lc_time_names(const char *name_arg)
    : sys_var_session(name_arg, __null)
  {

  }
  SHOW_TYPE show_type() { return SHOW_CHAR; }
  bool check_update_type(Item_result type)
  {
    return ((type != STRING_RESULT) && (type != INT_RESULT));
  }
  bool check_default(sql_var_t)
  { return 0; }
  bool update(Session *session, set_var *var);
  unsigned char *value_ptr(Session *session, sql_var_t type);
  virtual void set_default(Session *session, sql_var_t type);
};


struct sys_var_with_base
{
  sys_var* var;
  lex_string_t base_name;
};





drizzle_show_var* enumerate_sys_vars(Session*);
void add_sys_var_to_list(sys_var*, option*);
void add_sys_var_to_list(sys_var*);
sys_var* find_sys_var(const std::string&);

extern sys_var_str sys_var_general_log_path, sys_var_slow_log_path;

}
# 44 "./drizzled/sql_lex.h" 2
# 1 "./drizzled/item/func.h" 1
# 20 "./drizzled/item/func.h"
       


# 1 "./drizzled/function/math/divide.h" 1
# 20 "./drizzled/function/math/divide.h"
       


# 1 "./drizzled/function/num_op.h" 1
# 20 "./drizzled/function/num_op.h"
       



namespace drizzled
{



class Item_num_op :public Item_func_numhybrid
{
 public:
  Item_num_op(Item *a,Item *b) :Item_func_numhybrid(a, b) {}
  virtual void result_precision()= 0;

  virtual inline void print(String *str)
  {
    print_op(str);
  }

  void find_num_type();
  String *str_op(String *)
  { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/function/num_op.h", 42, __PRETTY_FUNCTION__)); return 0; }
};

}
# 24 "./drizzled/function/math/divide.h" 2

namespace drizzled
{

class Item_func_div :public Item_num_op
{
  Session *session;
public:
  uint32_t prec_increment;
  Item_func_div(Session *arg, Item *a,Item *b) :Item_num_op(a,b), session(arg) {}
  int64_t int_op() { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/function/math/divide.h", 34, __PRETTY_FUNCTION__)); return 0; }
  double real_op();
  type::Decimal *decimal_op(type::Decimal *);
  const char *func_name() const { return "/"; }
  void fix_length_and_dec();
  void result_precision();
};

}
# 24 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/get_user_var.h" 1
# 20 "./drizzled/function/get_user_var.h"
       




namespace drizzled {

class Item_func_get_user_var :public Item_func
{
  user_var_entry *var_entry;
  Item_result m_cached_result_type;
  Session &session;

public:
  str_ref name;
  Item_func_get_user_var(Session &session_arg, str_ref a) :
    Item_func(),
    m_cached_result_type(STRING_RESULT),
    session(session_arg),
    name(a)
  {}
  enum Functype functype() const { return GUSERVAR_FUNC; }
  str_ref get_name() { return name; }
  double val_real();
  int64_t val_int();
  type::Decimal *val_decimal(type::Decimal*);
  String *val_str(String* str);
  void fix_length_and_dec();
  virtual void print(String *str);
  enum Item_result result_type() const;




  const char *func_name() const { return "get_user_var"; }
  bool const_item() const;
  table_map used_tables() const
  { return const_item() ? 0 : (((table_map) 1) << (sizeof(table_map)*8-1)); }
  bool eq(const Item *item, bool binary_cmp) const;
};

}
# 25 "./drizzled/item/func.h" 2

# 1 "./drizzled/function/math/int_divide.h" 1
# 20 "./drizzled/function/math/int_divide.h"
       




namespace drizzled
{

class Item_func_int_div :public Item_int_func
{
public:
  Item_func_int_div(Item *a,Item *b) :Item_int_func(a,b)
  {}
  int64_t val_int();
  const char *func_name() const { return "DIV"; }
  void fix_length_and_dec();

  virtual inline void print(String *str)
  {
    print_op(str);
  }

};

}
# 27 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/math/minus.h" 1
# 20 "./drizzled/function/math/minus.h"
       



# 1 "./drizzled/function/additive_op.h" 1
# 20 "./drizzled/function/additive_op.h"
       




namespace drizzled
{

class Item_func_additive_op :public Item_num_op
{
public:
  Item_func_additive_op(Item *a,Item *b) :Item_num_op(a,b) {}
  void result_precision();
};

}
# 25 "./drizzled/function/math/minus.h" 2

namespace drizzled
{

class Item_func_minus :public Item_func_additive_op
{
public:
  Item_func_minus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
  const char *func_name() const { return "-"; }
  int64_t int_op();
  double real_op();
  type::Decimal *decimal_op(type::Decimal *);
  void fix_length_and_dec();
};

}
# 28 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/math/mod.h" 1
# 20 "./drizzled/function/math/mod.h"
       




namespace drizzled
{

class Item_func_mod :public Item_num_op
{
public:
  Item_func_mod(Item *a,Item *b) :Item_num_op(a,b) {}
  int64_t int_op();
  double real_op();
  type::Decimal *decimal_op(type::Decimal *);
  const char *func_name() const { return "%"; }
  void result_precision();
  void fix_length_and_dec();
};

}
# 29 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/math/multiply.h" 1
# 20 "./drizzled/function/math/multiply.h"
       




namespace drizzled
{

class Item_func_mul :public Item_num_op
{
public:
  Item_func_mul(Item *a,Item *b) :Item_num_op(a,b) {}
  const char *func_name() const { return "*"; }
  int64_t int_op();
  double real_op();
  type::Decimal *decimal_op(type::Decimal *);
  void result_precision();
};

}
# 30 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/math/neg.h" 1
# 20 "./drizzled/function/math/neg.h"
       


# 1 "./drizzled/function/num1.h" 1
# 20 "./drizzled/function/num1.h"
       



namespace drizzled
{


class Item_func_num1: public Item_func_numhybrid
{
public:
  Item_func_num1(): Item_func_numhybrid() {}
  Item_func_num1(Item *a) :Item_func_numhybrid(a) {}
  Item_func_num1(Item *a, Item *b) :Item_func_numhybrid(a, b) {}

  void fix_num_length_and_dec();
  void find_num_type();
  String *str_op(String *)
  { ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/function/num1.h", 38, __PRETTY_FUNCTION__)); return 0; }
};

}
# 24 "./drizzled/function/math/neg.h" 2

namespace drizzled
{

class Item_func_neg :public Item_func_num1
{
  bool _is_negative;

public:
  Item_func_neg(Item *a) :
    Item_func_num1(a),
    _is_negative(true)
  {}

  double real_op();
  int64_t int_op();
  type::Decimal *decimal_op(type::Decimal *);
  const char *func_name() const { return "-"; }
  enum Functype functype() const { return NEG_FUNC; }
  void fix_length_and_dec();
  void fix_num_length_and_dec();
  uint32_t decimal_precision() const { return args[0]->decimal_precision(); }

  bool negative() const
  {
    return _is_negative;
  }
};

}
# 31 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/math/plus.h" 1
# 20 "./drizzled/function/math/plus.h"
       




namespace drizzled
{

class Item_func_plus :public Item_func_additive_op
{
public:
  Item_func_plus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
  const char *func_name() const { return "+"; }
  int64_t int_op();
  double real_op();
  type::Decimal *decimal_op(type::Decimal *);
};

}
# 32 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/rollup_const.h" 1
# 20 "./drizzled/function/rollup_const.h"
       




namespace drizzled
{






class Item_func_rollup_const :public Item_func
{
public:
  Item_func_rollup_const(Item *a) :Item_func(a)
  {
    name= a->name;
    name_length= a->name_length;
  }
  double val_real() { return args[0]->val_real(); }
  int64_t val_int() { return args[0]->val_int(); }
  String *val_str(String *str) { return args[0]->val_str(str); }
  type::Decimal *val_decimal(type::Decimal *dec) { return args[0]->val_decimal(dec); }
  const char *func_name() const { return "rollup_const"; }
  bool const_item() const { return 0; }
  Item_result result_type() const { return args[0]->result_type(); }
  void fix_length_and_dec()
  {
    collation= args[0]->collation;
    max_length= args[0]->max_length;
    decimals=args[0]->decimals;

    null_value= args[0]->is_null();
  }
};

}
# 33 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/math/round.h" 1
# 20 "./drizzled/function/math/round.h"
       




namespace drizzled
{

class Item_func_round :public Item_func_num1
{
  bool truncate;
public:
  Item_func_round(Item *a, Item *b, bool trunc_arg)
    :Item_func_num1(a,b), truncate(trunc_arg) {}
  const char *func_name() const { return truncate ? "truncate" : "round"; }
  double real_op();
  int64_t int_op();
  type::Decimal *decimal_op(type::Decimal *);
  void fix_length_and_dec();
};

}
# 34 "./drizzled/item/func.h" 2
# 1 "./drizzled/function/user_var_as_out_param.h" 1
# 20 "./drizzled/function/user_var_as_out_param.h"
       



namespace drizzled {
# 35 "./drizzled/function/user_var_as_out_param.h"
class Item_user_var_as_out_param : public Item
{
  str_ref name;
  user_var_entry *entry;
public:
  Item_user_var_as_out_param(str_ref a) : name(a) {}

  Type type() const { return STRING_ITEM;}
  double val_real();
  int64_t val_int();
  String *val_str(String*);
  type::Decimal *val_decimal(type::Decimal *decimal_buffer);

  bool fix_fields(Session*, Item **ref);
  virtual void print(String*);
  void set_null_value(const charset_info_st*);
  void set_value(str_ref, const charset_info_st*);
};

}
# 35 "./drizzled/item/func.h" 2



namespace drizzled {

enum Cast_target
{
  ITEM_CAST_BINARY,
  ITEM_CAST_SIGNED,
  ITEM_CAST_UNSIGNED,
  ITEM_CAST_DATE,
  ITEM_CAST_TIME,
  ITEM_CAST_DATETIME,
  ITEM_CAST_CHAR,
  ITEM_CAST_BOOLEAN,
  ITEM_CAST_DECIMAL
};

}
# 45 "./drizzled/sql_lex.h" 2
# 69 "./drizzled/sql_lex.h"
namespace drizzled
{

typedef List<Item> List_item;

enum sub_select_type
{
  UNSPECIFIED_TYPE,
  UNION_TYPE,
  INTERSECT_TYPE,
  EXCEPT_TYPE,
  GLOBAL_OPTIONS_TYPE,
  DERIVED_TABLE_TYPE,
  OLAP_TYPE
};

enum olap_type
{
  UNSPECIFIED_OLAP_TYPE,
  CUBE_TYPE,
  ROLLUP_TYPE
};
# 210 "./drizzled/sql_lex.h"
class Select_Lex_Node {
protected:
  Select_Lex_Node *next, **prev,
    *master, *slave,
    *link_next, **link_prev;
public:

  uint64_t options;
# 227 "./drizzled/sql_lex.h"
  std::bitset<8> uncacheable;
  sub_select_type linkage;
  bool no_table_names_allowed;
  bool no_error;

  static void *operator new(size_t size)
  {
    return memory::sql_alloc(size);
  }
  static void *operator new(size_t size, memory::Root *mem_root)
  { return mem_root->alloc(size); }
  static void operator delete(void*, size_t)
  { }
  static void operator delete(void*, memory::Root*)
  {}
  Select_Lex_Node(): linkage(UNSPECIFIED_TYPE) {}
  virtual ~Select_Lex_Node() {}
  inline Select_Lex_Node* get_master() { return master; }
  virtual void init_query();
  virtual void init_select();
  void include_down(Select_Lex_Node *upper);
  void include_neighbour(Select_Lex_Node *before);
  void include_standalone(Select_Lex_Node *sel, Select_Lex_Node **ref);
  void include_global(Select_Lex_Node **plink);
  void exclude();

  virtual Select_Lex_Unit* master_unit()= 0;
  virtual Select_Lex* outer_select()= 0;
  virtual Select_Lex* return_after_parsing()= 0;

  virtual bool set_braces(bool value);
  virtual bool inc_in_sum_expr();
  virtual uint32_t get_in_sum_expr();
  virtual TableList* get_table_list();
  virtual List<Item>* get_item_list();
  virtual TableList *add_table_to_list(Session *session, Table_ident *table,
                                       lex_string_t *alias,
                                       const std::bitset<NUM_OF_TABLE_OPTIONS>& table_options,
                                       thr_lock_type flags= TL_UNLOCK,
                                       List<Index_hint> *hints= 0,
                                       lex_string_t *option= 0);
  virtual void set_lock_for_tables(thr_lock_type)
  {}

  friend class Select_Lex_Unit;
  friend bool new_select(LEX *lex, bool move_down);
private:
  void fast_exclude();
};





class Select_Lex_Unit: public Select_Lex_Node {
protected:
  TableList result_table_list;
  select_union *union_result;
  Table *table;

  select_result *result;
  uint64_t found_rows_for_union;
  bool saved_error;

public:
  bool prepared,
    optimized,
    executed,
    cleaned;


  List<Item> item_list;
# 310 "./drizzled/sql_lex.h"
  List<Item> types;




  Select_Lex *global_parameters;

  Select_Lex *return_to;

  ha_rows select_limit_cnt, offset_limit_cnt;

  Item_subselect *item;

  Session *session;




  Select_Lex *fake_select_lex;

  Select_Lex *union_distinct;
  bool describe;

  void init_query();
  Select_Lex_Unit* master_unit();
  Select_Lex* outer_select();
  Select_Lex* first_select()
  {
    return reinterpret_cast<Select_Lex*>(slave);
  }
  Select_Lex_Unit* next_unit()
  {
    return reinterpret_cast<Select_Lex_Unit*>(next);
  }
  Select_Lex* return_after_parsing() { return return_to; }
  void exclude_level();
  void exclude_tree();


  bool prepare(Session *session, select_result *result,
               uint64_t additional_options);
  bool exec();
  bool cleanup();
  inline void unclean() { cleaned= 0; }
  void reinit_exec_mechanism();

  void print(String *str);

  bool add_fake_select_lex(Session *session);
  void init_prepare_fake_select_lex(Session *session);
  bool change_result(select_result_interceptor *result,
                     select_result_interceptor *old_result);
  void set_limit(Select_Lex *values);
  void set_session(Session *session_arg) { session= session_arg; }
  inline bool is_union();

  friend void lex_start(Session*);

  List<Item> *get_unit_column_types();
};




class Select_Lex : public Select_Lex_Node
{
public:

  Select_Lex() :
    context(),
    db(0),
    where(0),
    having(0),
    cond_value(),
    having_value(),
    parent_lex(0),
    olap(UNSPECIFIED_OLAP_TYPE),
    table_list(),
    group_list(),
    item_list(),
    interval_list(),
    is_item_list_lookup(false),
    join(0),
    top_join_list(),
    join_list(0),
    embedding(0),
    sj_nests(),
    leaf_tables(0),
    type(optimizer::ST_PRIMARY),
    order_list(),
    gorder_list(0),
    select_limit(0),
    offset_limit(0),
    ref_pointer_array(0),
    select_n_having_items(0),
    cond_count(0),
    between_count(0),
    max_equal_elems(0),
    select_n_where_fields(0),
    parsing_place(NO_MATTER),
    with_sum_func(0),
    in_sum_expr(0),
    select_number(0),
    nest_level(0),
    inner_sum_func_list(0),
    with_wild(0),
    braces(0),
    having_fix_field(0),
    inner_refs_list(),
    n_sum_items(0),
    n_child_sum_items(0),
    explicit_limit(0),
    is_cross(false),
    subquery_in_having(0),
    is_correlated(0),
    exclude_from_table_unique_test(0),
    non_agg_fields(),
    cur_pos_in_select_list(0),
    prev_join_using(0),
    full_group_by_flag(),
    current_index_hint_type(INDEX_HINT_IGNORE),
    current_index_hint_clause(),
    index_hints(0)
  {
  }

  Name_resolution_context context;
  const char *db;

  Item *where;

  Item *having;

  Item::cond_result cond_value;
  Item::cond_result having_value;

  LEX *parent_lex;
  olap_type olap;

  SQL_LIST table_list;
  SQL_LIST group_list;
  List<Item> item_list;
  List<String> interval_list;
  bool is_item_list_lookup;
  Join *join;
  List<TableList> top_join_list;
  List<TableList> *join_list;
  TableList *embedding;
  List<TableList> sj_nests;





  TableList *leaf_tables;
  drizzled::optimizer::select_type type;

  SQL_LIST order_list;
  SQL_LIST *gorder_list;
  Item *select_limit, *offset_limit;

  Item **ref_pointer_array;






  uint32_t select_n_having_items;
  uint32_t cond_count;
  uint32_t between_count;
  uint32_t max_equal_elems;




  uint32_t select_n_where_fields;
  enum_parsing_place parsing_place;
  bool with_sum_func;

  uint32_t in_sum_expr;
  uint32_t select_number;
  int8_t nest_level;
  Item_sum *inner_sum_func_list;
  uint32_t with_wild;
  bool braces;

  bool having_fix_field;

  List<Item_outer_ref> inner_refs_list;

  uint32_t n_sum_items;

  uint32_t n_child_sum_items;


  bool explicit_limit;


  bool is_cross;





  bool subquery_in_having;

  bool is_correlated;

  bool exclude_from_table_unique_test;

  List<Item_field> non_agg_fields;

  int cur_pos_in_select_list;
# 538 "./drizzled/sql_lex.h"
  List<String> *prev_join_using;
# 548 "./drizzled/sql_lex.h"
  std::bitset<2> full_group_by_flag;

  void init_query();
  void init_select();
  Select_Lex_Unit* master_unit();
  Select_Lex_Unit* first_inner_unit()
  {
    return (Select_Lex_Unit*) slave;
  }
  Select_Lex* outer_select();
  Select_Lex* next_select()
  {
    return (Select_Lex*) next;
  }
  Select_Lex* next_select_in_list()
  {
    return (Select_Lex*) link_next;
  }
  Select_Lex_Node** next_select_in_list_addr()
  {
    return &link_next;
  }
  Select_Lex* return_after_parsing()
  {
    return master_unit()->return_after_parsing();
  }

  void mark_as_dependent(Select_Lex *last);

  bool set_braces(bool value);
  bool inc_in_sum_expr();
  uint32_t get_in_sum_expr();

  void add_item_to_list(Session *session, Item *item);
  void add_group_to_list(Session *session, Item *item, bool asc);
  void add_order_to_list(Session *session, Item *item, bool asc);
  TableList* add_table_to_list(Session *session,
                               Table_ident *table,
                               lex_string_t *alias,
                               const std::bitset<NUM_OF_TABLE_OPTIONS>& table_options,
                               thr_lock_type flags= TL_UNLOCK,
                               List<Index_hint> *hints= 0,
                               lex_string_t *option= 0);
  TableList* get_table_list();
  void init_nested_join(Session&);
  TableList *end_nested_join();
  TableList *nest_last_join(Session*);
  void add_joined_table(TableList *table);
  TableList *convert_right_join();
  List<Item>* get_item_list();
  void set_lock_for_tables(thr_lock_type lock_type);
  inline void init_order()
  {
    order_list.elements= 0;
    order_list.first= 0;
    order_list.next= (unsigned char**) &order_list.first;
  }






  void cut_subtree()
  {
    slave= 0;
  }
  bool test_limit();

  friend void lex_start(Session*);
  void make_empty_select()
  {
    init_query();
    init_select();
  }
  void setup_ref_array(Session *session, uint32_t order_group_num);
  void print(Session *session, String *str);
  static void print_order(String *str, Order *order);

  void print_limit(Session *session, String *str);
  void fix_prepare_information(Session *session, Item **conds, Item **having_conds);




  bool cleanup();




  void cleanup_all_joins(bool full);

  void set_index_hint_type(index_hint_type type, index_clause_map clause);





  void add_index_hint(Session*, const char*);


  void alloc_index_hints (Session *session);

  List<Index_hint>* pop_index_hints()
  {
    List<Index_hint> *hints= index_hints;
    index_hints= __null;
    return hints;
  }

  void clear_index_hints() { index_hints= __null; }

private:

  index_hint_type current_index_hint_type;
  index_clause_map current_index_hint_clause;

  List<Index_hint> *index_hints;
};

inline bool Select_Lex_Unit::is_union()
{
  return first_select()->next_select() && first_select()->next_select()->linkage == UNION_TYPE;
}

enum xa_option_words
{
  XA_NONE,
  XA_JOIN,
  XA_RESUME,
  XA_ONE_PHASE,
  XA_SUSPEND,
  XA_FOR_MIGRATE
};
# 693 "./drizzled/sql_lex.h"
class Query_tables_list
{
public:

  TableList *query_tables;

  TableList **query_tables_last;






  TableList **query_tables_own_last;


  void reset_query_tables_list(bool init);






  void add_to_query_tables(TableList *table)
  {
    *(table->prev_global= query_tables_last)= table;
    query_tables_last= &table->next_global;
  }

  TableList* first_not_own_table()
  {
    return ( query_tables_own_last ? *query_tables_own_last : 0);
  }
  void chop_off_not_own_tables()
  {
    if (query_tables_own_last)
    {
      *query_tables_own_last= 0;
      query_tables_last= query_tables_own_last;
      query_tables_own_last= 0;
    }
  }
};




enum enum_comment_state
{



  NO_COMMENT,




  PRESERVE_COMMENT,






  DISCARD_COMMENT
};

}

namespace drizzled {


class LEX : public Query_tables_list
{
public:
  Select_Lex_Unit unit;
  Select_Lex select_lex;

  Select_Lex *current_select;

  Select_Lex *all_selects_list;


  const char *length;

  const char *dec;







  lex_string_t name;

  String *wild;
  file_exchange *exchange;
  select_result *result;







  lex_string_t ident;

  unsigned char* yacc_yyss, *yacc_yyvs;

  Session *session;
  const charset_info_st *charset;
  bool text_string_is_7bit;

  TableList *leaf_tables_insert;

  List<Key_part_spec> col_list;
  List<Key_part_spec> ref_list;
  List<String> interval_list;
  List<Lex_Column> columns;
  List<Item> *insert_list,field_list,value_list,update_list;
  List<List_item> many_values;
  SetVarVector var_list;
# 828 "./drizzled/sql_lex.h"
  List<Name_resolution_context> context_stack;

  SQL_LIST auxiliary_table_list;
  SQL_LIST save_list;
  CreateField *last_field;
  Item_sum *in_sum_func;
  plugin::Function *udf;
  uint32_t type;
# 845 "./drizzled/sql_lex.h"
  nesting_map allow_sum_func;
  enum_sql_command sql_command;
  statement::Statement *statement;






  bool expr_allows_subselect;

  thr_lock_type lock_option;
  enum enum_duplicates duplicates;
  union {
    enum ha_rkey_function ha_rkey_mode;
    enum xa_option_words xa_opt;
  };
  sql_var_t option_type;

  int nest_level;
  uint8_t describe;




  uint8_t derived_tables;


  bool ignore;







  bool use_only_table_context;


  bool escape_used;
  bool is_lex_started;

  LEX();






  virtual ~LEX();

  TableList *unlink_first_table(bool *link_to_local);
  void link_first_table_back(TableList *first, bool link_to_local);
  void first_lists_tables_same();

  void cleanup_after_one_table_open();

  void push_context(Name_resolution_context *context)
  {
    context_stack.push_front(context);
  }

  void pop_context()
  {
    context_stack.pop();
  }

  Name_resolution_context *current_context()
  {
    return &context_stack.front();
  }
# 924 "./drizzled/sql_lex.h"
  bool is_single_level_stmt()
  {





    if (&select_lex == all_selects_list)
    {
      ((!all_selects_list->next_select_in_list()) ? static_cast<void> (0) : __assert_fail ("!all_selects_list->next_select_in_list()", "./drizzled/sql_lex.h", 933, __PRETTY_FUNCTION__));
      return true;
    }
    return false;
  }
  bool is_cross;
  bool isCacheable()
  {
    return cacheable;
  }
  void setCacheable(bool val)
  {
    cacheable= val;
  }

  void reset()
  {
    sum_expr_used= false;
    _exists= false;
  }

  void setSumExprUsed()
  {
    sum_expr_used= true;
  }

  bool isSumExprUsed()
  {
    return sum_expr_used;
  }

  void start(Session *session);
  void end();

  message::Table *table()
  {
    if (not _create_table)
      _create_table= new message::Table;

    return _create_table;
  }

  message::AlterTable *alter_table();

  message::Table::Field *field()
  {
    return _create_field;
  }

  void setField(message::Table::Field *arg)
  {
    _create_field= arg;
  }

  void setExists()
  {
    _exists= true;
  }

  bool exists() const
  {
    return _exists;
  }

private:
  bool cacheable;
  bool sum_expr_used;
  message::Table *_create_table;
  message::AlterTable *_alter_table;
  message::Table::Field *_create_field;
  bool _exists;
};

extern void lex_start(Session *session);





}
# 37 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/sql_select.h" 1
# 20 "./drizzled/sql_select.h"
       


# 1 "./drizzled/field/varstring.h" 1
# 21 "./drizzled/field/varstring.h"
       

# 1 "./drizzled/field/str.h" 1
# 21 "./drizzled/field/str.h"
       





namespace drizzled
{



class __attribute__ ((visibility("default"))) Field_str :
  public Field
{
protected:
  const charset_info_st *field_charset;
  enum Derivation field_derivation;
  int report_if_important_data(const char *ptr, const char *end);
public:
  Field_str(unsigned char *ptr_arg,
            uint32_t len_arg,
            unsigned char *null_ptr_arg,
            unsigned char null_bit_arg,
            const char *field_name_arg,
            const charset_info_st * const charset);
  Item_result result_type () const { return STRING_RESULT; }
  uint32_t decimals() const { return (uint8_t)31; }

  using Field::store;
  int store(double nr);
  int store(int64_t nr, bool unsigned_val)=0;
  int store_decimal(const type::Decimal *);
  int store(const char *to,uint32_t length, const charset_info_st * const cs)=0;

  uint32_t size_of() const { return sizeof(*this); }
  const charset_info_st *charset(void) const { return field_charset; }
  void set_charset(const charset_info_st * const charset_arg)
  { field_charset= charset_arg; }
  enum Derivation derivation(void) const { return field_derivation; }
  virtual void set_derivation(enum Derivation derivation_arg)
  { field_derivation= derivation_arg; }
  bool binary() const { return field_charset == &my_charset_bin; }
  uint32_t max_display_length() { return field_length; }
  friend class CreateField;
  type::Decimal *val_decimal(type::Decimal *) const;
  virtual bool str_needs_quotes() { return true; }
  uint32_t max_data_length() const;
};
# 96 "./drizzled/field/str.h"
bool check_string_copy_error(Field_str *field,
                             const char *well_formed_error_pos,
                             const char *cannot_convert_error_pos,
                             const char *end,
                             const charset_info_st * const cs);


}
# 24 "./drizzled/field/varstring.h" 2


namespace drizzled
{

class Field_varstring :public Field_str {
public:

  using Field::store;
  using Field::pack;
  using Field::unpack;
  using Field::val_int;
  using Field::val_str;





  static const uint32_t MAX_SIZE;
private:

  uint32_t length_bytes;
public:
  Field_varstring(unsigned char *ptr_arg,
                  uint32_t len_arg,
                  uint32_t length_bytes_arg,
                  unsigned char *null_ptr_arg,
                  unsigned char null_bit_arg,
                  const char *field_name_arg,
                  const charset_info_st * const cs);
  Field_varstring(uint32_t len_arg,
                  bool maybe_null_arg,
                  const char *field_name_arg,
                  const charset_info_st * const cs);

  enum_field_types type() const { return DRIZZLE_TYPE_VARCHAR; }
  enum ha_base_keytype key_type() const;
  bool zero_pack() const { return 0; }
  int reset(void) { memset(ptr, 0, field_length+length_bytes); return 0; }
  uint32_t pack_length() const { return (uint32_t) field_length+length_bytes; }
  uint32_t pack_length_no_ptr() const { return length_bytes; }
  uint32_t key_length() const { return (uint32_t) field_length; }
  uint32_t sort_length() const
  {
    return (uint32_t) field_length + (field_charset == &my_charset_bin ?
                                      length_bytes : 0);
  }
  int store(const char *to,uint32_t length, const charset_info_st * const charset);


  int store(int64_t nr, bool unsigned_val);
  int store(double nr) { return Field_str::store(nr); }
  double val_real(void) const;
  int64_t val_int(void) const;
  String *val_str(String*,String *) const;
  inline String *val_str(String *str) { return val_str(str, str); }
  type::Decimal *val_decimal(type::Decimal *) const;
  int cmp_max(const unsigned char *, const unsigned char *, uint32_t max_length);
  inline int cmp(const unsigned char *str) { return cmp(ptr,str); }
  int cmp(const unsigned char *a,const unsigned char *b)
  {
    return cmp_max(a, b, (4294967295U));
  }
  void sort_string(unsigned char *buff,uint32_t length);
  uint32_t get_key_image(unsigned char *buff,uint32_t length);
  uint32_t get_key_image(std::basic_string <unsigned char> &buff, uint32_t length);
  void set_key_image(const unsigned char *buff,uint32_t length);
  virtual unsigned char *pack(unsigned char *to,
                              const unsigned char *from,
                              uint32_t max_length,
                              bool low_byte_first);

  virtual const unsigned char *unpack(unsigned char* to,
                                      const unsigned char *from,
                                      uint32_t param_data,
                                      bool low_byte_first);

  int cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t max_length=(4294967295U));
  int key_cmp(const unsigned char *,const unsigned char*);
  int key_cmp(const unsigned char *str, uint32_t length);
  uint32_t max_packed_col_length(uint32_t max_length);
  uint32_t used_length();
  uint32_t size_of() const { return sizeof(*this); }
  enum_field_types real_type() const { return DRIZZLE_TYPE_VARCHAR; }
  bool has_charset(void) const
  { return charset() == &my_charset_bin ? false : true; }
  Field *new_field(memory::Root *root, Table *new_table, bool keep_type);
  Field *new_key_field(memory::Root *root, Table *new_table,
                       unsigned char *new_ptr, unsigned char *new_null_ptr,
                       uint32_t new_null_bit);
};

}
# 24 "./drizzled/sql_select.h" 2
# 1 "./drizzled/item/null.h" 1
# 20 "./drizzled/item/null.h"
       




namespace drizzled {

class Item_null : public Item_basic_constant
{
public:

  Item_null(const char *name_par=0)
  {
    maybe_null= null_value= true;
    max_length= 0;
    name= name_par ? name_par : "NULL";
    fixed= 1;
    collation.set(&my_charset_bin, DERIVATION_IGNORABLE);
  }
  Type type() const { return NULL_ITEM; }
  bool eq(const Item *item, bool binary_cmp) const;
  double val_real();
  int64_t val_int();
  String *val_str(String *str);
  type::Decimal *val_decimal(type::Decimal *);
  int save_in_field(Field *field, bool no_conversions);
  int save_safe_in_field(Field *field);
  void send(plugin::Client *client, String *str);
  enum Item_result result_type () const { return STRING_RESULT; }
  enum_field_types field_type() const { return DRIZZLE_TYPE_NULL; }
  bool basic_const_item() const { return 1; }
  Item *clone_item() { return new Item_null(name); }
  bool is_null() { return true; }

  virtual void print(String *str);

  Item *safe_charset_converter(const charset_info_st * const tocs);
};

class Item_null_result :public Item_null
{
public:
  Field *result_field;
  Item_null_result() : Item_null(), result_field(0) {}
  bool is_result_field() { return result_field != 0; }
  void save_in_result_field(bool no_conversions)
  {
    save_in_field(result_field, no_conversions);
  }
};

}
# 25 "./drizzled/sql_select.h" 2
# 1 "./drizzled/enum_nested_loop_state.h" 1
# 20 "./drizzled/enum_nested_loop_state.h"
       



namespace drizzled {


enum enum_nested_loop_state
{
  NESTED_LOOP_KILLED= -2,
  NESTED_LOOP_ERROR= -1,
  NESTED_LOOP_OK= 0,
  NESTED_LOOP_NO_MORE_ROWS= 1,
  NESTED_LOOP_QUERY_LIMIT= 3,
  NESTED_LOOP_CURSOR_LIMIT= 4
};

typedef enum_nested_loop_state (*Next_select_func)(Join *, JoinTable *, bool);
typedef int (*Read_record_func)(JoinTable *tab);
Next_select_func setup_end_select_func(Join *join);

}
# 26 "./drizzled/sql_select.h" 2
# 1 "./drizzled/optimizer/position.h" 1
# 20 "./drizzled/optimizer/position.h"
       

# 1 "./drizzled/join_table.h" 1
# 28 "./drizzled/join_table.h"
       


# 1 "./drizzled/table_reference.h" 1
# 28 "./drizzled/table_reference.h"
       




namespace drizzled {

struct table_reference_st
{
  table_reference_st() :
    key_err(false),
    key_parts(0),
    key_length(0),
    key(0),
    key_buff(__null),
    key_buff2(__null),
    key_copy(__null),
    items(__null),
    cond_guards(__null),
    null_ref_key(__null),
    disable_cache(false)
  { }

  bool key_err;
  uint32_t key_parts;
  uint32_t key_length;
  int32_t key;
  unsigned char *key_buff;
  unsigned char *key_buff2;
  StoredKey **key_copy;
  Item **items;
# 70 "./drizzled/table_reference.h"
  bool **cond_guards;




  key_part_map null_rejecting;
  table_map depend_map;

  unsigned char *null_ref_key;




  bool disable_cache;
};

}
# 32 "./drizzled/join_table.h" 2
# 1 "./drizzled/optimizer/range.h" 1
# 22 "./drizzled/optimizer/range.h"
       





# 1 "/usr/include/c++/4.8/queue" 1 3
# 58 "/usr/include/c++/4.8/queue" 3
       
# 59 "/usr/include/c++/4.8/queue" 3





# 1 "/usr/include/c++/4.8/bits/stl_queue.h" 1 3
# 62 "/usr/include/c++/4.8/bits/stl_queue.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 92 "/usr/include/c++/4.8/bits/stl_queue.h" 3
  template<typename _Tp, typename _Sequence = deque<_Tp> >
    class queue
    {

      typedef typename _Sequence::value_type _Sequence_value_type;
     
     
     
     

      template<typename _Tp1, typename _Seq1>
        friend bool
        operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);

      template<typename _Tp1, typename _Seq1>
        friend bool
        operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);

    public:
      typedef typename _Sequence::value_type value_type;
      typedef typename _Sequence::reference reference;
      typedef typename _Sequence::const_reference const_reference;
      typedef typename _Sequence::size_type size_type;
      typedef _Sequence container_type;

    protected:
# 126 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      _Sequence c;

    public:




      explicit
      queue(const _Sequence& __c = _Sequence())
      : c(__c) { }
# 149 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      bool
      empty() const
      { return c.empty(); }


      size_type
      size() const
      { return c.size(); }





      reference
      front()
      {
 ;
 return c.front();
      }





      const_reference
      front() const
      {
 ;
 return c.front();
      }





      reference
      back()
      {
 ;
 return c.back();
      }





      const_reference
      back() const
      {
 ;
 return c.back();
      }
# 211 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      void
      push(const value_type& __x)
      { c.push_back(__x); }
# 237 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      void
      pop()
      {
 ;
 c.pop_front();
      }
# 253 "/usr/include/c++/4.8/bits/stl_queue.h" 3
    };
# 266 "/usr/include/c++/4.8/bits/stl_queue.h" 3
  template<typename _Tp, typename _Seq>
    inline bool
    operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c == __y.c; }
# 284 "/usr/include/c++/4.8/bits/stl_queue.h" 3
  template<typename _Tp, typename _Seq>
    inline bool
    operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c < __y.c; }


  template<typename _Tp, typename _Seq>
    inline bool
    operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Seq>
    inline bool
    operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Seq>
    inline bool
    operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Seq>
    inline bool
    operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__x < __y); }
# 365 "/usr/include/c++/4.8/bits/stl_queue.h" 3
  template<typename _Tp, typename _Sequence = vector<_Tp>,
    typename _Compare = less<typename _Sequence::value_type> >
    class priority_queue
    {

      typedef typename _Sequence::value_type _Sequence_value_type;
     
     
     
     
     


    public:
      typedef typename _Sequence::value_type value_type;
      typedef typename _Sequence::reference reference;
      typedef typename _Sequence::const_reference const_reference;
      typedef typename _Sequence::size_type size_type;
      typedef _Sequence container_type;

    protected:

      _Sequence c;
      _Compare comp;

    public:




      explicit
      priority_queue(const _Compare& __x = _Compare(),
       const _Sequence& __s = _Sequence())
      : c(__s), comp(__x)
      { std::make_heap(c.begin(), c.end(), comp); }
# 430 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      template<typename _InputIterator>
        priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x = _Compare(),
         const _Sequence& __s = _Sequence())
 : c(__s), comp(__x)
        {
   ;
   c.insert(c.end(), __first, __last);
   std::make_heap(c.begin(), c.end(), comp);
 }
# 467 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      bool
      empty() const
      { return c.empty(); }


      size_type
      size() const
      { return c.size(); }





      const_reference
      top() const
      {
 ;
 return c.front();
      }
# 495 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      void
      push(const value_type& __x)
      {
 c.push_back(__x);
 std::push_heap(c.begin(), c.end(), comp);
      }
# 530 "/usr/include/c++/4.8/bits/stl_queue.h" 3
      void
      pop()
      {
 ;
 std::pop_heap(c.begin(), c.end(), comp);
 c.pop_back();
      }
# 548 "/usr/include/c++/4.8/bits/stl_queue.h" 3
    };
# 566 "/usr/include/c++/4.8/bits/stl_queue.h" 3

}
# 65 "/usr/include/c++/4.8/queue" 2 3
# 29 "./drizzled/optimizer/range.h" 2



namespace drizzled {

typedef struct st_key_part
{
  uint16_t key;
  uint16_t part;

  uint16_t store_length;
  uint16_t length;
  uint8_t null_bit;




  uint8_t flag;
  Field *field;
} KEY_PART;


namespace optimizer {
# 95 "./drizzled/optimizer/range.h"
class QuickSelectInterface
{
public:
  bool sorted;
  ha_rows records;
  double read_time;
  Table *head;




  uint32_t index;




  uint32_t max_used_key_length;







  uint32_t used_key_parts;




  unsigned char *last_rowid;




  unsigned char *record;

  QuickSelectInterface();
  virtual ~QuickSelectInterface(){};
# 152 "./drizzled/optimizer/range.h"
  virtual int init() = 0;
# 171 "./drizzled/optimizer/range.h"
  virtual int reset(void) = 0;

  virtual int get_next() = 0;


  virtual void range_end() {}

  virtual bool reverse_sorted() const = 0;

  virtual bool unique_key_range() const
  {
    return false;
  }

  enum
  {
    QS_TYPE_RANGE= 0,
    QS_TYPE_INDEX_MERGE= 1,
    QS_TYPE_RANGE_DESC= 2,
    QS_TYPE_ROR_INTERSECT= 4,
    QS_TYPE_ROR_UNION= 5,
    QS_TYPE_GROUP_MIN_MAX= 6
  };


  virtual int get_type() const = 0;
# 212 "./drizzled/optimizer/range.h"
  virtual int init_ror_merged_scan(bool)
  {
    ((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/optimizer/range.h", 214, __PRETTY_FUNCTION__));
    return 1;
  }




  virtual void save_last_pos(){};







  virtual void add_keys_and_lengths(std::string *key_names,
                                    std::string *used_lengths)=0;
# 241 "./drizzled/optimizer/range.h"
  virtual void add_info_string(std::string *)
  {}





  virtual bool is_keys_used(const boost::dynamic_bitset<>& fields);
};





typedef struct st_quick_range_seq_ctx
{
  QuickRange **first;
  QuickRange **cur;
  QuickRange **last;
} QuickRangeSequenceContext;

range_seq_t quick_range_seq_init(void *init_param, uint32_t n_ranges, uint32_t flags);

uint32_t quick_range_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range);
# 274 "./drizzled/optimizer/range.h"
class SqlSelect : public memory::SqlAlloc
{
 public:
  QuickSelectInterface *quick;
  COND *cond;
  Table *head;
  internal::io_cache_st *file;
  ha_rows records;
  double read_time;
  key_map quick_keys;
  key_map needed_reg;
  table_map const_tables;
  table_map read_tables;
  bool free_cond;

  SqlSelect();
  ~SqlSelect();
  void cleanup();
  bool check_quick(Session *session, bool force_quick_range, ha_rows limit);
  bool skip_record();
  int test_quick_select(Session *session, key_map keys, table_map prev_tables,
                        ha_rows limit, bool force_quick_range,
                        bool ordered_output);
};

QuickRangeSelect *get_quick_select_for_ref(Session *session,
                                           Table *table,
                                           table_reference_st *ref,
                                           ha_rows records);
# 326 "./drizzled/optimizer/range.h"
QuickRangeSelect *get_quick_select(Parameter *param,
                                   uint32_t index,
                                   SEL_ARG *key_tree,
                                   uint32_t mrr_flags,
                                   uint32_t mrr_buf_size,
                                   memory::Root *alloc);

uint32_t get_index_for_order(Table *table, Order *order, ha_rows limit);

SqlSelect *make_select(Table *head,
                       table_map const_tables,
                       table_map read_tables,
                       COND *conds,
                       bool allow_null_cond,
                       int *error);

bool get_quick_keys(Parameter *param,
                    QuickRangeSelect *quick,
                    KEY_PART *key,
                    SEL_ARG *key_tree,
                    unsigned char *min_key,
                    uint32_t min_key_flag,
                    unsigned char *max_key,
                    uint32_t max_key_flag);

}

}
# 33 "./drizzled/join_table.h" 2
# 1 "./drizzled/join_cache.h" 1
# 20 "./drizzled/join_cache.h"
       

namespace drizzled {





class CacheField {




public:
  unsigned char *str;
  uint32_t length;
  uint32_t blob_length;
  Field_blob *blob_field;
  bool strip;
  Table *get_rowid;

  CacheField():
    str(__null),
    length(0),
    blob_length(0),
    blob_field(__null),
    strip(false),
    get_rowid(__null)
  {}

};

class JoinCache
{
public:
  unsigned char *buff;
  unsigned char *pos;
  unsigned char *end;
  uint32_t records;
  uint32_t record_nr;
  uint32_t ptr_record;







  uint32_t fields;
  uint32_t length;
  uint32_t blobs;
  CacheField *field;
  CacheField **blob_ptr;
  optimizer::SqlSelect *select;

  JoinCache():
    buff(__null),
    pos(__null),
    end(__null),
    records(0),
    record_nr(0),
    ptr_record(0),
    fields(0),
    length(0),
    blobs(0),
    field(__null),
    blob_ptr(__null),
    select(__null)
  {}

  void reset_cache_read();
  void reset_cache_write();
  bool store_record_in_cache();
};

int join_init_cache(Session *session, JoinTable *tables, uint32_t table_count);

}
# 34 "./drizzled/join_table.h" 2
# 1 "./drizzled/optimizer/key_use.h" 1
# 20 "./drizzled/optimizer/key_use.h"
       

namespace drizzled
{
namespace optimizer
{

class KeyUse
{
public:

  KeyUse()
    :
      table(__null),
      val(__null),
      used_tables(0),
      key(0),
      keypart(0),
      optimize(0),
      keypart_map(0),
      ref_table_rows(0),
      null_rejecting(false),
      cond_guard(__null)
  {}

  KeyUse(Table *in_table,
         Item *in_val,
         table_map in_used_tables,
         uint32_t in_key,
         uint32_t in_keypart,
         uint32_t in_optimize,
         key_part_map in_keypart_map,
         ha_rows in_ref_table_rows,
         bool in_null_rejecting,
         bool *in_cond_guard)
    :
      table(in_table),
      val(in_val),
      used_tables(in_used_tables),
      key(in_key),
      keypart(in_keypart),
      optimize(in_optimize),
      keypart_map(in_keypart_map),
      ref_table_rows(in_ref_table_rows),
      null_rejecting(in_null_rejecting),
      cond_guard(in_cond_guard)
  {}

  Table *getTable()
  {
    return table;
  }

  Item *getVal()
  {
    return val;
  }

  table_map getUsedTables() const
  {
    return used_tables;
  }

  uint32_t getKey() const
  {
    return key;
  }

  uint32_t getKeypart() const
  {
    return keypart;
  }

  uint32_t getOptimizeFlags() const
  {
    return optimize;
  }

  key_part_map getKeypartMap() const
  {
    return keypart_map;
  }

  ha_rows getTableRows() const
  {
    return ref_table_rows;
  }

  void setTableRows(ha_rows input)
  {
    ref_table_rows= input;
  }

  bool isNullRejected() const
  {
    return null_rejecting;
  }

  bool *getConditionalGuard()
  {
    return cond_guard;
  }

private:

  Table *table;

  Item *val;

  table_map used_tables;

  uint32_t key;

  uint32_t keypart;

  uint32_t optimize;

  key_part_map keypart_map;

  ha_rows ref_table_rows;





  bool null_rejecting;
# 157 "./drizzled/optimizer/key_use.h"
  bool *cond_guard;
};

}

}
# 35 "./drizzled/join_table.h" 2

# 1 "./drizzled/records.h" 1
# 20 "./drizzled/records.h"
       



namespace drizzled {


struct ReadRecord {
  Table *table;
  Cursor *cursor;
  Table **forms;
  int (*read_record)(ReadRecord *);
  Session *session;
  optimizer::SqlSelect *select;
  uint32_t cache_records;
  uint32_t ref_length;
  uint32_t struct_length;
  uint32_t reclength;
  uint32_t rec_cache_size;
  uint32_t error_offset;
  uint32_t index;
  unsigned char *ref_pos;
  unsigned char *record;
  unsigned char *rec_buf;
private:
  unsigned char *cache;
public:
  unsigned char *getCache()
  {
    return cache;
  }
  unsigned char *cache_pos;
  unsigned char *cache_end;
  unsigned char *read_positions;
  internal::io_cache_st *io_cache;
  bool print_error;
  bool ignore_not_found_rows;
  JoinTable *do_insideout_scan;
  ReadRecord() :
    table(__null),
    cursor(__null),
    forms(0),
    read_record(0),
    session(0),
    select(0),
    cache_records(0),
    ref_length(0),
    struct_length(0),
    reclength(0),
    rec_cache_size(0),
    error_offset(0),
    index(0),
    ref_pos(0),
    record(0),
    rec_buf(0),
    cache(0),
    cache_pos(0),
    cache_end(0),
    read_positions(0),
    io_cache(0),
    print_error(0),
    ignore_not_found_rows(0),
    do_insideout_scan(0)
  {
  }

  void init()
  {
    table= __null;
    cursor= __null;
    forms= 0;
    read_record= 0;
    session= 0;
    select= 0;
    cache_records= 0;
    ref_length= 0;
    struct_length= 0;
    reclength= 0;
    rec_cache_size= 0;
    error_offset= 0;
    index= 0;
    ref_pos= 0;
    record= 0;
    rec_buf= 0;
    cache= 0;
    cache_pos= 0;
    cache_end= 0;
    read_positions= 0;
    io_cache= 0;
    print_error= 0;
    ignore_not_found_rows= 0;
    do_insideout_scan= 0;
  }

  virtual ~ReadRecord()
  { }
# 185 "./drizzled/records.h"
  int init_read_record(Session *session,
                       Table *reg_form,
                       optimizer::SqlSelect *select,
                       int use_record_cache,
                       bool print_errors) __attribute__ ((warn_unused_result));

  void end_read_record();
# 209 "./drizzled/records.h"
  int init_read_record_idx(Session *session,
                           Table *table,
                           bool print_error,
                           uint32_t idx) __attribute__ ((warn_unused_result));

  void init_reard_record_sequential();

  bool init_rr_cache();
};

}
# 37 "./drizzled/join_table.h" 2



namespace drizzled {
# 49 "./drizzled/join_table.h"
enum access_method
{
  AM_UNKNOWN,
  AM_SYSTEM,
  AM_CONST,
  AM_EQ_REF,
  AM_REF,
  AM_MAYBE_REF,
 AM_ALL,
  AM_RANGE,
  AM_NEXT,
  AM_REF_OR_NULL,
  AM_UNIQUE_SUBQUERY,
  AM_INDEX_SUBQUERY,
  AM_INDEX_MERGE
};


class JoinTable
{
public:
  JoinTable() :
    table(__null),
    keyuse(__null),
    select(__null),
    select_cond(__null),
    quick(__null),
    pre_idx_push_select_cond(__null),
    on_expr_ref(__null),
    cond_equal(__null),
    first_inner(__null),
    found(false),
    not_null_compl(false),
    last_inner(__null),
    first_upper(__null),
    first_unmatched(__null),
    packed_info(0),
    read_first_record(__null),
    next_select(__null),
    worst_seeks(0.0),
    const_keys(0),
    checked_keys(0),
    needed_reg(0),
    keys(0),
    records(0),
    found_records(0),
    read_time(0),
    dependent(0),
    key_dependent(0),
    use_quick(0),
    index(0),
    status(0),
    used_fields(0),
    used_fieldlength(0),
    used_blobs(0),
    type(AM_UNKNOWN),
    cached_eq_ref_table(0),
    eq_ref_table(0),
    not_used_in_distinct(0),
    sorted(0),
    limit(0),
    join(__null),
    insideout_match_tab(__null),
    insideout_buf(__null),
    found_match(false),
    rowid_keep_flags(0),
    embedding_map(0)
  {}
  Table *table;
  optimizer::KeyUse *keyuse;
  optimizer::SqlSelect *select;
  COND *select_cond;
  optimizer::QuickSelectInterface *quick;







  Item *pre_idx_push_select_cond;
  Item **on_expr_ref;
  COND_EQUAL *cond_equal;
  JoinTable *first_inner;
  bool found;
  bool not_null_compl;
  JoinTable *last_inner;
  JoinTable *first_upper;
  JoinTable *first_unmatched;


  const char *info;




  uint32_t packed_info;

  Read_record_func read_first_record;
  Next_select_func next_select;
  ReadRecord read_record;





  Read_record_func save_read_first_record;
  int (*save_read_record) (ReadRecord *);
  double worst_seeks;
  key_map const_keys;
  key_map checked_keys;
  key_map needed_reg;
  key_map keys;


  ha_rows records;




  ha_rows found_records;





  ha_rows read_time;

  table_map dependent;
  table_map key_dependent;
  uint32_t use_quick;
  uint32_t index;
  uint32_t status;
  uint32_t used_fields;
  uint32_t used_fieldlength;
  uint32_t used_blobs;
  enum access_method type;
  bool cached_eq_ref_table;
  bool eq_ref_table;
  bool not_used_in_distinct;

  bool sorted;





  ha_rows limit;
  table_reference_st ref;
  JoinCache cache;
  Join *join;







  JoinTable *insideout_match_tab;
  unsigned char *insideout_buf;


  bool found_match;

  enum
  {

    KEEP_ROWID=1,






    CALL_POSITION=2
  };

  int rowid_keep_flags;


  std::bitset<64> embedding_map;

  void cleanup();

  inline bool is_using_loose_index_scan()
  {
    return (select && select->quick &&
            (select->quick->get_type() ==
             optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX));
  }

  void readCachedRecord();
  int joinReadConstTable(optimizer::Position *pos);
  int joinReadSystem();
};

int join_read_system(JoinTable *tab);

}
# 23 "./drizzled/optimizer/position.h" 2

namespace drizzled
{
namespace optimizer
{





class Position
{
public:

  Position()
    :
      records_read(0),
      read_time(0),
      table(__null),
      key(__null),
      ref_depend_map(0)
  {}

  Position(double in_records_read,
           double in_read_time,
           JoinTable *in_table,
           KeyUse *in_key,
           table_map in_ref_depend_map)
    :
      records_read(in_records_read),
      read_time(in_read_time),
      table(in_table),
      key(in_key),
      ref_depend_map(in_ref_depend_map)
  {}

  Position(const Position &rhs)
    :
      records_read(rhs.records_read),
      read_time(rhs.read_time),
      table(rhs.table),
      key(rhs.key),
      ref_depend_map(rhs.ref_depend_map)
  {}

  Position &operator=(const Position &rhs)
  {
    if (this == &rhs)
    {
      return *this;
    }
    records_read= rhs.records_read;
    read_time= rhs.read_time;
    table= rhs.table;
    key= rhs.key;
    ref_depend_map= rhs.ref_depend_map;
    return *this;
  }
# 96 "./drizzled/optimizer/position.h"
  bool isConstTable() const
  {
    return (records_read < 2.0);
  }

  double getFanout() const
  {
    return records_read;
  }

  void setFanout(double in_records_read)
  {
    records_read= in_records_read;
  }

  double getCost() const
  {
    return read_time;
  }

  JoinTable *getJoinTable()
  {
    return table;
  }
# 128 "./drizzled/optimizer/position.h"
  bool hasTableForSorting(Table *cmp_table) const
  {
    return (cmp_table != table->table);
  }

  bool examinePosition(table_map found_ref);

  KeyUse *getKeyUse()
  {
    return key;
  }

  table_map getRefDependMap() const
  {
    return ref_depend_map;
  }

  void clearRefDependMap()
  {
    ref_depend_map= 0;
  }

private:






  double records_read;






  double read_time;

  JoinTable *table;





  KeyUse *key;


  table_map ref_depend_map;

};

}

}
# 27 "./drizzled/sql_select.h" 2
# 1 "./drizzled/optimizer/sargable_param.h" 1
# 20 "./drizzled/optimizer/sargable_param.h"
       

namespace drizzled
{
namespace optimizer
{
# 40 "./drizzled/optimizer/sargable_param.h"
class SargableParam
{
public:
  SargableParam()
    :
      field(__null),
      arg_value(__null),
      num_values(0)
  {}

  SargableParam(Field *in_field,
                Item **in_arg_value,
                uint32_t in_num_values)
    :
      field(in_field),
      arg_value(in_arg_value),
      num_values(in_num_values)
  {}

  SargableParam(const SargableParam &rhs)
    :
      field(rhs.field),
      arg_value(rhs.arg_value),
      num_values(rhs.num_values)
  {}

  SargableParam &operator=(const SargableParam &rhs)
  {
    if (this == &rhs)
    {
      return *this;
    }
    field= rhs.field;
    arg_value= rhs.arg_value;
    num_values= rhs.num_values;
    return *this;
  }

  Field *getField()
  {
    return field;
  }

  uint32_t getNumValues() const
  {
    return num_values;
  }

  bool isConstItem(uint32_t index)
  {
    return (arg_value[index]->const_item());
  }

private:




  Field *field;




  Item **arg_value;




  uint32_t num_values;
};

}

}
# 28 "./drizzled/sql_select.h" 2




# 1 "./drizzled/stored_key.h" 1
# 20 "./drizzled/stored_key.h"
       


# 1 "./drizzled/copy_field.h" 1
# 21 "./drizzled/copy_field.h"
       





namespace drizzled {




class CopyField :public memory::SqlAlloc
{




  typedef void Copy_func(CopyField*);
  Copy_func *get_copy_func(Field *to, Field *from);

public:
  unsigned char *from_ptr;
  unsigned char *to_ptr;
  unsigned char *from_null_ptr;
  unsigned char *to_null_ptr;
  bool *null_row;
  uint32_t from_bit;
  uint32_t to_bit;
  uint32_t from_length;
  uint32_t to_length;
  Field *from_field;
  Field *to_field;
  String tmp;

  CopyField() :
    from_ptr(0),
    to_ptr(0),
    from_null_ptr(0),
    to_null_ptr(0),
    null_row(0),
    from_bit(0),
    to_bit(0),
    from_length(0),
    to_length(0),
    from_field(0),
    to_field(0)
  {}

  ~CopyField()
  {}

  void set(Field *to,Field *from,bool save);
  void set(unsigned char *to,Field *from);
  void (*do_copy)(CopyField *);
  void (*do_copy2)(CopyField *);
};

}
# 24 "./drizzled/stored_key.h" 2


namespace drizzled {


class StoredKey :public memory::SqlAlloc
{
public:
  bool null_key;
  enum store_key_result
  {
    STORE_KEY_OK,
    STORE_KEY_FATAL,
    STORE_KEY_CONV
  };

protected:
  Field *to_field;
  unsigned char *null_ptr;
  unsigned char err;
  virtual enum store_key_result copy_inner()=0;

public:
  StoredKey(Session *session,
            Field *field_arg,
            unsigned char *ptr,
            unsigned char *null,
            uint32_t length);

  virtual ~StoredKey() {}
  virtual const char *name() const=0;







  enum store_key_result copy();

};

class store_key_field: public StoredKey
{
  CopyField copy_field;
  const char *field_name;

public:
  store_key_field(Session *session, Field *to_field_arg, unsigned char *ptr,
                  unsigned char *null_ptr_arg,
                  uint32_t length, Field *from_field, const char *name_arg) :
    StoredKey(session, to_field_arg,ptr,
              null_ptr_arg ? null_ptr_arg : from_field->maybe_null() ? &err
              : (unsigned char*) 0, length), field_name(name_arg)
    {
    if (to_field)
    {
      copy_field.set(to_field,from_field,0);
    }
  }
  const char *name() const { return field_name; }

protected:
  enum store_key_result copy_inner()
  {
    copy_field.do_copy(&copy_field);
    null_key= to_field->is_null();
    return err != 0 ? STORE_KEY_FATAL : STORE_KEY_OK;
  }
};

class store_key_item :public StoredKey
{
protected:
  Item *item;

public:
  store_key_item(Session *session, Field *to_field_arg, unsigned char *ptr,
                 unsigned char *null_ptr_arg, uint32_t length, Item *item_arg) :
    StoredKey(session, to_field_arg, ptr,
        null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
        &err : (unsigned char*) 0, length), item(item_arg)
  {}
  const char *name() const { return "func"; }

 protected:
  enum store_key_result copy_inner()
  {
    int res= item->save_in_field(to_field, 1);
    null_key= to_field->is_null() || item->null_value;
    return (err != 0 || res > 2 ? STORE_KEY_FATAL : (store_key_result) res);
  }
};

class store_key_const_item :public store_key_item
{
  bool inited;

public:
  store_key_const_item(Session *session, Field *to_field_arg, unsigned char *ptr,
                       unsigned char *null_ptr_arg, uint32_t length,
                       Item *item_arg) :
    store_key_item(session, to_field_arg,ptr,
                   null_ptr_arg ? null_ptr_arg : item_arg->maybe_null ?
                   &err : (unsigned char*) 0, length, item_arg), inited(0)
  {
  }
  const char *name() const { return "const"; }

protected:
  enum store_key_result copy_inner()
  {
    int res;
    if (!inited)
    {
      inited=1;
      if ((res= item->save_in_field(to_field, 1)))
      {
        if (!err)
          err= res;
      }
    }
    null_key= to_field->is_null() || item->null_value;
    return (err > 2 ? STORE_KEY_FATAL : (store_key_result) err);
  }
};

}
# 33 "./drizzled/sql_select.h" 2



namespace drizzled {
# 49 "./drizzled/sql_select.h"
enum_nested_loop_state sub_select_cache(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state sub_select(Join *join,JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_send_group(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_write_group(Join *join, JoinTable *join_tab, bool end_of_records);

class Rollup
{
public:
  enum State { STATE_NONE, STATE_INITED, STATE_READY };

  Rollup()
  :
  state(),
  null_items(__null),
  ref_pointer_arrays(__null),
  fields()
  {}

  Rollup(State in_state,
         Item_null_result **in_null_items,
         Item ***in_ref_pointer_arrays,
         List<Item> *in_fields)
  :
  state(in_state),
  null_items(in_null_items),
  ref_pointer_arrays(in_ref_pointer_arrays),
  fields(in_fields)
  {}

  State getState() const
  {
    return state;
  }

  void setState(State in_state)
  {
    state= in_state;
  }

  Item_null_result **getNullItems() const
  {
    return null_items;
  }

  void setNullItems(Item_null_result **in_null_items)
  {
    null_items= in_null_items;
  }

  Item ***getRefPointerArrays() const
  {
    return ref_pointer_arrays;
  }

  void setRefPointerArrays(Item ***in_ref_pointer_arrays)
  {
    ref_pointer_arrays= in_ref_pointer_arrays;
  }

  List<Item> *getFields() const
  {
    return fields;
  }

  void setFields(List<Item> *in_fields)
  {
    fields= in_fields;
  }

private:
  State state;
  Item_null_result **null_items;
  Item ***ref_pointer_arrays;
  List<Item> *fields;
};

}



# 1 "./drizzled/join.h" 1
# 27 "./drizzled/join.h"
       

# 1 "./drizzled/dynamic_array.h" 1
# 21 "./drizzled/dynamic_array.h"
       

# 1 "/usr/include/c++/4.8/cstddef" 1 3
# 39 "/usr/include/c++/4.8/cstddef" 3
       
# 40 "/usr/include/c++/4.8/cstddef" 3


# 1 "/usr/lib/gcc/i686-linux-gnu/4.8/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8/cstddef" 2 3
# 24 "./drizzled/dynamic_array.h" 2

namespace drizzled {

class DYNAMIC_ARRAY
{
public:
  unsigned char *buffer;
  size_t max_element;
  uint32_t alloc_increment;
  uint32_t size_of_element;

  unsigned char* alloc();
  void free();
  void init(uint32_t element_size, uint32_t init_alloc, uint32_t alloc_increment);
  void push_back(void*);

  size_t size() const
  {
    return elements;
  }

  void set_size(size_t v)
  {
    elements = v;
  }
private:
  size_t elements;
};

}
# 30 "./drizzled/join.h" 2


# 1 "./drizzled/tmp_table_param.h" 1
# 21 "./drizzled/tmp_table_param.h"
       

# 1 "./plugin/myisam/myisam.h" 1
# 18 "./plugin/myisam/myisam.h"
       




# 1 "./plugin/myisam/my_handler.h" 1
# 18 "./plugin/myisam/my_handler.h"
       


# 1 "./plugin/myisam/myisampack.h" 1
# 16 "./plugin/myisam/myisampack.h"
       
# 22 "./plugin/myisam/my_handler.h" 2
# 45 "./plugin/myisam/my_handler.h"
typedef struct st_HA_KEYSEG
{
  const drizzled::charset_info_st *charset;
  uint32_t start;
  uint32_t null_pos;
  uint16_t bit_pos;
  uint16_t flag;
  uint16_t length;
  uint8_t type;
  uint8_t language;
  uint8_t null_bit;
  uint8_t bit_start,bit_end;
  uint8_t bit_length;
} HA_KEYSEG;
# 106 "./plugin/myisam/my_handler.h"
extern int ha_compare_text(const drizzled::charset_info_st * const, unsigned char *, uint, unsigned char *, uint, bool, bool);

extern HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, unsigned char *a);
void my_handler_error_register(void);
extern int ha_key_cmp(HA_KEYSEG *keyseg, unsigned char *a,unsigned char *b,
                      uint32_t key_length,uint32_t nextflag,uint32_t *diff_length);
# 24 "./plugin/myisam/myisam.h" 2
# 1 "./drizzled/internal/iocache.h" 1
# 21 "./drizzled/internal/iocache.h"
       



namespace drizzled {
namespace internal {



class io_cache_st
{
public:
  typedef int (*IO_CACHE_CALLBACK)(io_cache_st*);


  my_off_t pos_in_file;





  my_off_t end_of_file;

  unsigned char *read_pos;

  unsigned char *read_end;
  unsigned char *buffer;

  unsigned char *request_pos;


  unsigned char *write_buffer;






  unsigned char *append_read_pos;

  unsigned char *write_pos;

  unsigned char *write_end;







  unsigned char **current_pos, **current_end;
# 80 "./drizzled/internal/iocache.h"
  int (*read_function)(io_cache_st* ,unsigned char *,size_t);




  int (*write_function)(io_cache_st* ,const unsigned char *,size_t);





  cache_type type;
  int error;







  IO_CACHE_CALLBACK pre_read;
  IO_CACHE_CALLBACK post_read;
  IO_CACHE_CALLBACK pre_close;
  void* arg;
  char *file_name;
  char *dir,*prefix;
  int file;







  int seek_not_done;

  size_t buffer_length;

  size_t read_length;
  myf myflags;






  bool alloced_buffer;

  io_cache_st() :
    pos_in_file(0),
    end_of_file(0),
    read_pos(0),
    read_end(0),
    buffer(0),
    request_pos(0),
    write_buffer(0),
    append_read_pos(0),
    write_pos(0),
    write_end(0),
    current_pos(0),
    current_end(0),
    read_function(0),
    write_function(0),
    type(TYPE_NOT_SET),
    error(0),
    pre_read(0),
    post_read(0),
    pre_close(0),
    arg(0),
    file_name(0),
    dir(0),
    prefix(0),
    file(0),
    seek_not_done(0),
    buffer_length(0),
    read_length(0),
    myflags(0),
    alloced_buffer(0)
  { }

  int get();
  int block_write(const void*, size_t, my_off_t);
  void close_cached_file();
  bool real_open_cached_file();
  int end_io_cache();
  int init_io_cache(int file, size_t cachesize, cache_type type, my_off_t seek_offset, bool use_async_io, myf cache_myflags);
  void init_functions();

  bool reinit_io_cache(cache_type type_arg, my_off_t seek_offset, bool use_async_io, bool clear_cache);
  void setup_io_cache();
  bool open_cached_file(const char *dir, const char *prefix, size_t cache_size, myf cache_myflags);
  int flush(int need_append_buffer_lock= 1);

  void clear()
  {
    buffer= __null;
  }

  bool inited() const
  {
    return buffer;
  }

  my_off_t tell() const
  {
    return pos_in_file + *current_pos - request_pos;
  }

  int read(void* Buffer0, size_t Count)
  {
    unsigned char* Buffer= reinterpret_cast<unsigned char*>(Buffer0);
    if (read_pos + Count > read_end)
      return read_function(this, Buffer, Count);
    memcpy(Buffer, read_pos, Count);
    read_pos += Count;
    return 0;
  }

  int write(const void* Buffer0, size_t Count)
  {
    const unsigned char* Buffer= reinterpret_cast<const unsigned char*>(Buffer0);
    if (write_pos + Count > write_end)
      return write_function(this, Buffer, Count);
    memcpy(write_pos, Buffer, Count);
    write_pos += Count;
    return 0;
  }
};

}
}
# 25 "./plugin/myisam/myisam.h" 2
# 114 "./plugin/myisam/myisam.h"
typedef uint32_t ha_checksum;


typedef struct st_mi_isaminfo
{
  drizzled::ha_rows records;
  drizzled::ha_rows deleted;
  drizzled::internal::my_off_t recpos;
  drizzled::internal::my_off_t newrecpos;
  drizzled::internal::my_off_t dupp_key_pos;
  drizzled::internal::my_off_t data_file_length,
           max_data_file_length,
           index_file_length,
           max_index_file_length,
           delete_length;
  ulong reclength;
  ulong mean_reclength;
  uint64_t auto_increment;
  uint64_t key_map;
  char *data_file_name, *index_file_name;
  uint32_t keys;
  uint options;
  int errkey,
 sortkey;
  int filenr;
  time_t create_time;
  time_t check_time;
  time_t update_time;
  uint32_t reflength;
  ulong record_offset;
  ulong *rec_per_key;
} MI_ISAMINFO;


typedef struct st_mi_create_info
{
  const char *index_file_name, *data_file_name;
  drizzled::ha_rows max_rows;
  drizzled::ha_rows reloc_rows;
  uint64_t auto_increment;
  uint64_t data_file_length;
  uint64_t key_file_length;
  uint32_t old_options;
  uint8_t language;
  bool with_auto_increment;

  st_mi_create_info():
    index_file_name(0),
    data_file_name(0),
    max_rows(0),
    reloc_rows(0),
    auto_increment(0),
    data_file_length(0),
    key_file_length(0),
    old_options(0),
    language(0),
    with_auto_increment(0)
  { }

} MI_CREATE_INFO;

struct st_myisam_info;
struct st_mi_isam_share;
typedef struct st_myisam_info MI_INFO;
struct st_mi_s_param;

typedef struct st_mi_keydef
{
  struct st_mi_isam_share *share;
  uint16_t keysegs;
  uint16_t flag;

  uint8_t key_alg;
  uint16_t block_length;
  uint16_t underflow_block_length;
  uint16_t keylength;
  uint16_t minlength;
  uint16_t maxlength;
  uint16_t block_size_index;
  uint32_t version;

  HA_KEYSEG *seg,*end;

  int (*bin_search)(struct st_myisam_info *info,struct st_mi_keydef *keyinfo,
      unsigned char *page,unsigned char *key,
      uint32_t key_len,uint32_t comp_flag,unsigned char * *ret_pos,
      unsigned char *buff, bool *was_last_key);
  uint32_t (*get_key)(struct st_mi_keydef *keyinfo,uint32_t nod_flag,unsigned char * *page,
    unsigned char *key);
  int (*pack_key)(struct st_mi_keydef *keyinfo,uint32_t nod_flag,unsigned char *next_key,
    unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
    struct st_mi_s_param *s_temp);
  void (*store_key)(struct st_mi_keydef *keyinfo, unsigned char *key_pos,
      struct st_mi_s_param *s_temp);
  int (*ck_insert)(struct st_myisam_info *inf, uint32_t k_nr, unsigned char *k, uint32_t klen);
  int (*ck_delete)(struct st_myisam_info *inf, uint32_t k_nr, unsigned char *k, uint32_t klen);
} MI_KEYDEF;




typedef struct st_unique_def
{
  uint16_t keysegs;
  unsigned char key;
  uint8_t null_are_equal;
  HA_KEYSEG *seg,*end;
} MI_UNIQUEDEF;

typedef struct st_mi_decode_tree
{
  uint16_t *table;
  uint quick_table_bits;
  unsigned char *intervalls;
} MI_DECODE_TREE;


struct st_mi_bit_buff;







namespace drizzled
{

typedef struct st_columndef
{
  int16_t type;
  uint16_t length;
  uint32_t offset;
  uint8_t null_bit;
  uint16_t null_pos;


  void (*unpack)(struct st_columndef *rec,struct st_mi_bit_buff *buff,
   unsigned char *start,unsigned char *end);
  enum drizzled::en_fieldtype base_type;
  uint32_t space_length_bits,pack_type;
  MI_DECODE_TREE *huff_tree;

} MI_COLUMNDEF;

}


extern char * myisam_log_filename;
extern uint32_t myisam_block_size;
extern uint32_t myisam_concurrent_insert;
extern uint32_t myisam_bulk_insert_tree_size;
extern uint32_t data_pointer_size;



extern int mi_close(struct st_myisam_info *file);
extern int mi_delete(struct st_myisam_info *file,const unsigned char *buff);
extern struct st_myisam_info *mi_open(const drizzled::identifier::Table &identifier,
                                      int mode,
          uint32_t wait_if_locked);
extern int mi_panic(enum drizzled::ha_panic_function function);
extern int mi_rfirst(struct st_myisam_info *file,unsigned char *buf,int inx);
extern int mi_rkey(MI_INFO *info, unsigned char *buf, int inx, const unsigned char *key,
                   drizzled::key_part_map keypart_map, enum drizzled::ha_rkey_function search_flag);
extern int mi_rlast(struct st_myisam_info *file,unsigned char *buf,int inx);
extern int mi_rnext(struct st_myisam_info *file,unsigned char *buf,int inx);
extern int mi_rnext_same(struct st_myisam_info *info, unsigned char *buf);
extern int mi_rprev(struct st_myisam_info *file,unsigned char *buf,int inx);
extern int mi_rrnd(struct st_myisam_info *file,unsigned char *buf, drizzled::internal::my_off_t pos);
extern int mi_scan_init(struct st_myisam_info *file);
extern int mi_scan(struct st_myisam_info *file,unsigned char *buf);
extern int mi_rsame(struct st_myisam_info *file,unsigned char *record,int inx);
extern int mi_update(struct st_myisam_info *file,const unsigned char *old,
       unsigned char *new_record);
extern int mi_write(struct st_myisam_info *file,unsigned char *buff);
extern drizzled::internal::my_off_t mi_position(struct st_myisam_info *file);
extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint32_t flag);
extern int mi_lock_database(struct st_myisam_info *file,int lock_type);
extern int mi_create(const char *name,uint32_t keys,MI_KEYDEF *keydef,
       uint32_t columns, drizzled::MI_COLUMNDEF *columndef,
       uint32_t uniques, MI_UNIQUEDEF *uniquedef,
       MI_CREATE_INFO *create_info, uint32_t flags);
extern int mi_delete_table(const char *name);
extern int mi_rename(const char *from, const char *to);
extern int mi_extra(struct st_myisam_info *file,
      enum drizzled::ha_extra_function function,
      void *extra_arg);
extern int mi_reset(struct st_myisam_info *file);
extern drizzled::ha_rows mi_records_in_range(MI_INFO *info, int inx,
                                   drizzled::key_range *min_key, drizzled::key_range *max_key);
extern int mi_log(int activate_log);
extern int mi_delete_all_rows(struct st_myisam_info *info);
extern ulong _mi_calc_blob_length(uint32_t length , const unsigned char *pos);
extern uint32_t mi_get_pointer_length(uint64_t file_length, uint32_t def);
# 365 "./plugin/myisam/myisam.h"
typedef struct st_sort_key_blocks
{
  unsigned char *buff,*end_pos;
  unsigned char lastkey[(1332 + 6 + 6)];
  uint32_t last_length;
  int inited;
} SORT_KEY_BLOCKS;
# 380 "./plugin/myisam/myisam.h"
typedef enum
{

  MI_STATS_METHOD_NULLS_NOT_EQUAL,

  MI_STATS_METHOD_NULLS_EQUAL,

  MI_STATS_METHOD_IGNORE_NULLS
} enum_mi_stats_method;

typedef struct st_mi_check_param
{
  uint64_t auto_increment_value;
  uint64_t max_data_file_length;
  uint64_t keys_in_use;
  uint64_t max_record_length;
  drizzled::internal::my_off_t search_after_block;
  drizzled::internal::my_off_t new_file_pos,key_file_blocks;
  drizzled::internal::my_off_t keydata,totaldata,key_blocks,start_check_pos;
  drizzled::ha_rows total_records,total_deleted;
  ha_checksum record_checksum,glob_crc;
  uint64_t use_buffers;
  size_t read_buffer_length, write_buffer_length,
         sort_buffer_length, sort_key_blocks;
  uint32_t out_flag,warning_printed,error_printed,verbose;
  uint32_t opt_sort_key,total_files,max_level;
  uint32_t testflag, key_cache_block_size;
  uint8_t language;
  bool using_global_keycache, opt_lock_memory, opt_follow_links;
  bool retry_repair, force_sort;
  char temp_filename[512],*isam_file_name;
  int tmpfile_createflag;
  drizzled::myf myf_rw;
  drizzled::internal::io_cache_st read_cache;





  uint64_t unique_count[16 +1];
  uint64_t notnull_count[16 +1];

  ha_checksum key_crc[255];
  ulong rec_per_key_part[16*255];
  void *session;
  const char *db_name, *table_name;
  const char *op_name;
  enum_mi_stats_method stats_method;
} MI_CHECK;

typedef struct st_sort_info
{
  drizzled::internal::my_off_t filelength,dupp,buff_length;
  drizzled::ha_rows max_records;
  uint32_t current_key, total_keys;
  drizzled::myf myf_rw;
  enum drizzled::data_file_type new_data_file_type;
  MI_INFO *info;
  MI_CHECK *param;
  unsigned char *buff;
  SORT_KEY_BLOCKS *key_block,*key_block_end;

  uint32_t got_error, threads_running;
  pthread_mutex_t mutex;
  pthread_cond_t cond;
} SORT_INFO;


void myisamchk_init(MI_CHECK *param);
int chk_status(MI_CHECK *param, MI_INFO *info);
int chk_del(MI_CHECK *param, register MI_INFO *info, uint32_t test_flag);
int chk_size(MI_CHECK *param, MI_INFO *info);
int chk_key(MI_CHECK *param, MI_INFO *info);
int chk_data_link(MI_CHECK *param, MI_INFO *info,int extend);
int mi_repair(MI_CHECK *param, register MI_INFO *info,
       char * name, int rep_quick);
int mi_sort_index(MI_CHECK *param, register MI_INFO *info, char * name);
int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
        const char * name, int rep_quick);
int change_to_newfile(const char * filename, const char * old_ext,
        const char * new_ext, uint32_t raid_chunks,
        drizzled::myf myflags);
void lock_memory(MI_CHECK *param);
void update_auto_increment_key(MI_CHECK *param, MI_INFO *info,
          bool repair);
int update_state_info(MI_CHECK *param, MI_INFO *info,uint32_t update);
void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part,
                      uint64_t *unique, uint64_t *notnull,
                      uint64_t records);
int filecopy(MI_CHECK *param, int to,int from,drizzled::internal::my_off_t start,
      drizzled::internal::my_off_t length, const char *type);
int movepoint(MI_INFO *info,unsigned char *record,drizzled::internal::my_off_t oldpos,
       drizzled::internal::my_off_t newpos, uint32_t prot_key);
int write_data_suffix(SORT_INFO *sort_info, bool fix_datafile);
int test_if_almost_full(MI_INFO *info);
bool mi_test_if_sort_rep(MI_INFO *info, drizzled::ha_rows rows, uint64_t key_map,
       bool force);

int mi_init_bulk_insert(MI_INFO *info, uint32_t cache_size, drizzled::ha_rows rows);
void mi_flush_bulk_insert(MI_INFO *info, uint32_t inx);
void mi_end_bulk_insert(MI_INFO *info);
int mi_preload(MI_INFO *info, uint64_t key_map, bool ignore_leaves);
# 24 "./drizzled/tmp_table_param.h" 2

namespace drizzled {







class Tmp_Table_Param : public memory::SqlAlloc, boost::noncopyable
{
public:
  KeyInfo *keyinfo;
  List<Item> copy_funcs;
  List<Item> save_copy_funcs;
  CopyField *copy_field, *copy_field_end;
  CopyField *save_copy_field, *save_copy_field_end;
  unsigned char *group_buff;
  Item **items_to_copy;
  MI_COLUMNDEF *recinfo,*start_recinfo;
  ha_rows end_write_records;
  uint32_t field_count;
  uint32_t sum_func_count;
  uint32_t func_count;
  uint32_t hidden_field_count;
  uint32_t group_parts,group_length,group_null_parts;
  uint32_t quick_group;
  bool using_indirect_summary_function;
  bool schema_table;







  bool precomputed_group_by;

  bool force_copy_fields;


  uint32_t convert_blob_length;

  const charset_info_st *table_charset;

  Tmp_Table_Param() :
    keyinfo(0),
    copy_funcs(),
    save_copy_funcs(),
    copy_field(0),
    copy_field_end(0),
    save_copy_field(0),
    save_copy_field_end(0),
    group_buff(0),
    items_to_copy(0),
    recinfo(0),
    start_recinfo(0),
    end_write_records(0),
    field_count(0),
    sum_func_count(0),
    func_count(0),
    hidden_field_count(0),
    group_parts(0),
    group_length(0),
    group_null_parts(0),
    quick_group(0),
    using_indirect_summary_function(false),
    schema_table(false),
    precomputed_group_by(false),
    force_copy_fields(false),
    convert_blob_length(0),
    table_charset(0)
  {}

  ~Tmp_Table_Param()
  {
    cleanup();
  }
  void init(void);
  void cleanup(void);
};

}
# 33 "./drizzled/join.h" 2


namespace drizzled {

class Join : public memory::SqlAlloc, boost::noncopyable
{




  optimizer::Position positions[(sizeof(table_map)*8-3)+1];





  optimizer::Position best_positions[(sizeof(table_map)*8-3)+1];

public:
  JoinTable *join_tab;
  JoinTable **best_ref;
  JoinTable **map2table;
  JoinTable *join_tab_save;

  Table **table;
  Table **all_tables;





  Table *sort_by_table;

  uint32_t tables;
  uint32_t outer_tables;
  uint32_t const_tables;
  uint32_t send_group_parts;

  bool sort_and_group;
  bool first_record;
  bool full_join;
  bool group;
  bool no_field_update;
  bool do_send_rows;




  bool resume_nested_loop;







  bool no_const_tables;
  bool select_distinct;







  bool group_optimized_away;






  bool simple_order;
  bool simple_group;




  bool no_order;

  bool skip_sort_order;
  bool union_part;
  bool optimized;
  bool need_tmp;
  bool hidden_group_fields;

  table_map const_table_map;
  table_map found_const_table_map;
  table_map outer_join;

  ha_rows send_records;
  ha_rows found_records;
  ha_rows examined_rows;
  ha_rows row_limit;
  ha_rows select_limit;
# 137 "./drizzled/join.h"
  ha_rows fetch_limit;

  Session *session;
  List<Item> *fields;
  List<Item> &fields_list;
  List<TableList> *join_list;

  Select_Lex_Unit *unit;

  Select_Lex *select_lex;
  optimizer::SqlSelect *select;





  std::bitset<64> cur_embedding_map;





  double best_read;
  List<Cached_item> group_fields;
  List<Cached_item> group_fields_cache;
  Table *tmp_table;

  Table *exec_tmp_table1;
  Table *exec_tmp_table2;
  Item_sum **sum_funcs;
  Item_sum ***sum_funcs_end;

  Item_sum **sum_funcs2;
  Item_sum ***sum_funcs_end2;
  Item *having;
  Item *tmp_having;
  Item *having_history;
  uint64_t select_options;
  select_result *result;
  Tmp_Table_Param tmp_table_param;
  DrizzleLock *lock;

  Join *tmp_join;
  Rollup rollup;
  DYNAMIC_ARRAY keyuse;
  Item::cond_result cond_value;
  Item::cond_result having_value;
  List<Item> all_fields;

  List<Item> tmp_all_fields1;
  List<Item> tmp_all_fields2;
  List<Item> tmp_all_fields3;

  List<Item> tmp_fields_list1;
  List<Item> tmp_fields_list2;
  List<Item> tmp_fields_list3;
  int error;

  Order *order;
  Order *group_list;
  COND *conds;
  Item *conds_history;
  TableList *tables_list;
  COND_EQUAL *cond_equal;
  JoinTable *return_tab;
  Item **ref_pointer_array;

  Item **items0;
  Item **items1;
  Item **items2;
  Item **items3;
  Item **current_ref_pointer_array;
  uint32_t ref_pointer_array_size;
  const char *zero_result_cause;
# 219 "./drizzled/join.h"
  SortField *sortorder;
  Table **table_reexec;
  JoinTable *join_tab_reexec;



  Join(Session *session_arg,
       List<Item> &fields_arg,
       uint64_t select_options_arg,
       select_result *result_arg);







  void reset(Session *session_arg,
             List<Item> &fields_arg,
             uint64_t select_options_arg,
             select_result *result_arg);

  int prepare(Item ***rref_pointer_array,
              TableList *tables,
              uint32_t wind_num,
              COND *conds,
              uint32_t og_num,
              Order *order,
              Order *group,
              Item *having,
              Select_Lex *select,
              Select_Lex_Unit *unit);

  int optimize();
  int reinit();
  void exec();
  int destroy();
  void restore_tmp();
  bool alloc_func_list();
  bool setup_subquery_materialization();
  bool make_sum_func_list(List<Item> &all_fields,
                          List<Item> &send_fields,
                       bool before_group_by,
                          bool recompute= false);

  inline void set_items_ref_array(Item **ptr)
  {
    memcpy(ref_pointer_array, ptr, ref_pointer_array_size);
    current_ref_pointer_array= ptr;
  }
  inline void init_items_ref_array()
  {
    items0= ref_pointer_array + all_fields.size();
    memcpy(items0, ref_pointer_array, ref_pointer_array_size);
    current_ref_pointer_array= items0;
  }

  bool rollup_init();
  bool rollup_make_fields(List<Item> &all_fields,
                          List<Item> &fields,
                       Item_sum ***func);
  int rollup_send_data(uint32_t idx);
  int rollup_write_data(uint32_t idx, Table *table);
  void remove_subq_pushed_predicates(Item **where);






  void join_free();

  void cleanup(bool full);
  void clear();
  void save_join_tab();
  void init_save_join_tab();
  bool send_row_on_empty_set()
  {
    return (do_send_rows && tmp_table_param.sum_func_count != 0 &&
     !group_list);
  }
  bool change_result(select_result *result);
  bool is_top_level_join() const;






  void copyPartialPlanIntoOptimalPlan(uint32_t size)
  {
    memcpy(best_positions, positions,
           sizeof(optimizer::Position) * size);
  }

  void cache_const_exprs();






  optimizer::Position &getPosFromOptimalPlan(uint32_t index)
  {
    return best_positions[index];
  }






  optimizer::Position &getPosFromPartialPlan(uint32_t index)
  {
    return positions[index];
  }





  void setPosInPartialPlan(uint32_t index, optimizer::Position &in_pos)
  {
    positions[index]= in_pos;
  }




  optimizer::Position *getFirstPosInPartialPlan()
  {
    return positions;
  }






  optimizer::Position *getSpecificPosInPartialPlan(int32_t index)
  {
    return positions + index;
  }

};

enum_nested_loop_state evaluate_join_record(Join *join, JoinTable *join_tab, int error);
enum_nested_loop_state evaluate_null_complemented_join_record(Join *join, JoinTable *join_tab);
enum_nested_loop_state flush_cached_records(Join *join, JoinTable *join_tab, bool skip_last);
enum_nested_loop_state end_send(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_write(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_update(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_unique_update(Join *join, JoinTable *join_tab, bool end_of_records);

}
# 130 "./drizzled/sql_select.h" 2

namespace drizzled
{
# 142 "./drizzled/sql_select.h"
typedef std::pair<Item*, Item_func*> COND_CMP;

void TEST_join(Join *join);


bool store_val_in_field(Field *field, Item *val, enum_check_fields check_flag);
Table *create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,
   Order *group, bool distinct, bool save_sum_fields,
   uint64_t select_options, ha_rows rows_limit,
   const char* alias);
void count_field_types(Select_Lex *select_lex, Tmp_Table_Param *param,
                       List<Item> &fields, bool reset_with_sum_func);
bool setup_copy_fields(Session *session, Tmp_Table_Param *param,
         Item **ref_pointer_array,
         List<Item> &new_list1, List<Item> &new_list2,
         uint32_t elements, List<Item> &fields);
void copy_fields(Tmp_Table_Param *param);
bool copy_funcs(Item **func_ptr, const Session *session);
Field* create_tmp_field_from_field(Session *session, Field* org_field,
                                   const char *name, Table *table,
                                   Item_field *item, uint32_t convert_blob_length);
bool test_if_ref(Item_field *left_item,Item *right_item);
COND *optimize_cond(Join *join, COND *conds, List<TableList> *join_list, Item::cond_result *cond_value);
COND *make_cond_for_table(COND *cond,table_map table, table_map used_table, bool exclude_expensive_cond);
COND* substitute_for_best_equal_field(COND *cond, COND_EQUAL *cond_equal, void *table_join_idx);
bool list_contains_unique_index(Table *table, bool (*find_func) (Field *, void *), void *data);
bool find_field_in_order_list (Field *field, void *data);
bool find_field_in_item_list (Field *field, void *data);
bool test_if_skip_sort_order(JoinTable *tab,Order *order,ha_rows select_limit, bool no_changes, const key_map *map);
Order *create_distinct_group(Session *session,
                                Item **ref_pointer_array,
                                Order *order_list,
                                List<Item> &fields,
                                List<Item> &,
                                bool *all_order_by_fields_used);

bool change_to_use_tmp_fields(Session *session,
                              Item **ref_pointer_array,
                           List<Item> &res_selected_fields,
                           List<Item> &res_all_fields,
                           uint32_t elements,
                              List<Item> &all_fields);
int do_select(Join *join, List<Item> *fields, Table *tmp_table);
bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
int create_sort_index(Session *session, Join *join, Order *order, ha_rows filesort_limit, ha_rows select_limit, bool is_order_by);
void save_index_subquery_explain_info(JoinTable *join_tab, Item* where);
Item *remove_additional_cond(Item* conds);
bool setup_sum_funcs(Session *session, Item_sum **func_ptr);
bool init_sum_functions(Item_sum **func, Item_sum **end);
bool update_sum_func(Item_sum **func);
void copy_sum_funcs(Item_sum **func_ptr, Item_sum **end);
bool change_refs_to_tmp_fields(Session *session,
                               Item **ref_pointer_array,
                               List<Item> &res_selected_fields,
                               List<Item> &res_all_fields,
                               uint32_t elements,
                            List<Item> &all_fields);
bool change_group_ref(Session *session, Item_func *expr, Order *group_list, bool *changed);
bool check_interleaving_with_nj(JoinTable *next);
void update_const_equal_items(COND *cond, JoinTable *tab);
int join_read_const(JoinTable *tab);
int join_read_key(JoinTable *tab);
int join_read_always_key(JoinTable *tab);
int join_read_last_key(JoinTable *tab);
int join_no_more_records(ReadRecord *info);
int join_read_next(ReadRecord *info);
int join_read_next_different(ReadRecord *info);
int join_init_quick_read_record(JoinTable *tab);
int init_read_record_seq(JoinTable *tab);
int test_if_quick_select(JoinTable *tab);
int join_init_read_record(JoinTable *tab);
int join_read_first(JoinTable *tab);
int join_read_next_same(ReadRecord *info);
int join_read_next_same_diff(ReadRecord *info);
int join_read_last(JoinTable *tab);
int join_read_prev_same(ReadRecord *info);
int join_read_prev(ReadRecord *info);
int join_read_always_key_or_null(JoinTable *tab);
int join_read_next_same_or_null(ReadRecord *info);

void calc_used_field_length(Session *, JoinTable *join_tab);
StoredKey *get_store_key(Session *session,
                         optimizer::KeyUse *keyuse,
                         table_map used_tables,
                         KeyPartInfo *key_part,
                         unsigned char *key_buff,
                         uint32_t maybe_null);
int join_tab_cmp(const void* ptr1, const void* ptr2);
int join_tab_cmp_straight(const void* ptr1, const void* ptr2);
void push_index_cond(JoinTable *tab, uint32_t keyno, bool other_tbls_ok);
void add_not_null_conds(Join *join);
uint32_t max_part_bit(key_part_map bits);
COND *add_found_match_trig_cond(JoinTable *tab, COND *cond, JoinTable *root_tab);
bool eq_ref_table(Join *join, Order *start_order, JoinTable *tab);
int remove_dup_with_compare(Session *session, Table *table, Field **first_field, uint32_t offset, Item *having);
int remove_dup_with_hash_index(Session *session,
                               Table *table,
                               uint32_t field_count,
                               Field **first_field,
                               uint32_t key_length,
                               Item *having);
void update_ref_and_keys(Session *session,
                         DYNAMIC_ARRAY *keyuse,
                         JoinTable *join_tab,
                         uint32_t tables,
                         COND *cond,
                         COND_EQUAL *,
                         table_map normal_tables,
                         Select_Lex *select_lex,
                         std::vector<optimizer::SargableParam> &sargables);
ha_rows get_quick_record_count(Session *session, optimizer::SqlSelect *select, Table *table, const key_map *keys,ha_rows limit);
void optimize_keyuse(Join *join, DYNAMIC_ARRAY *keyuse_array);
void add_group_and_distinct_keys(Join *join, JoinTable *join_tab);
void read_cached_record(JoinTable *tab);
bool select_query(Session *session, Item ***rref_pointer_array,
                  TableList *tables, uint32_t wild_num, List<Item> &list,
                  COND *conds, uint32_t og_num, Order *order, Order *group,
                  Item *having, uint64_t select_type,
                  select_result *result, Select_Lex_Unit *unit,
                  Select_Lex *select_lex);

void init_tmptable_sum_functions(Item_sum **func);
void update_tmptable_sum_func(Item_sum **func,Table *tmp_table);
bool only_eq_ref_tables(Join *join, Order *order, table_map tables);
bool create_ref_for_key(Join *join, JoinTable *j,
                        optimizer::KeyUse *org_keyuse,
                        table_map used_tables);

bool cp_buffer_from_ref(Session *session, table_reference_st *ref);
int safe_index_read(JoinTable *tab);
COND *remove_eq_conds(Session *session, COND *cond, Item::cond_result *cond_value);
int test_if_item_cache_changed(List<Cached_item> &list);

void print_join(Session *session, String *str, List<TableList> *tables);

}
# 38 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/system_variables.h" 1
# 21 "./drizzled/system_variables.h"
       

namespace drizzled {

struct drizzle_system_variables
{
# 36 "./drizzled/system_variables.h"
  ulong dynamic_variables_version;
  char * dynamic_variables_ptr;
  uint32_t dynamic_variables_head;
  uint32_t dynamic_variables_size;

  uint64_t myisam_max_extra_sort_file_size;
  uint64_t max_heap_table_size;
  uint64_t tmp_table_size;
  ha_rows select_limit;
  ha_rows max_join_size;
  uint64_t auto_increment_increment;
  uint64_t auto_increment_offset;
  uint64_t bulk_insert_buff_size;
  uint64_t join_buff_size;
  uint32_t max_allowed_packet;
  uint64_t max_error_count;
  uint64_t max_length_for_sort_data;
  size_t max_sort_length;
  uint64_t min_examined_row_limit;
  bool optimizer_prune_level;
  bool log_warnings;

  uint32_t optimizer_search_depth;
  uint32_t div_precincrement;
  uint64_t preload_buff_size;
  uint32_t read_buff_size;
  uint32_t read_rnd_buff_size;
  bool replicate_query;
  size_t sortbuff_size;
  uint32_t thread_handling;
  uint32_t tx_isolation;
  uint32_t completion_type;

  uint32_t sql_mode;
  uint64_t max_seeks_for_key;
  size_t range_alloc_block_size;
  uint32_t query_alloc_block_size;
  uint32_t query_prealloc_size;
  uint64_t group_concat_max_len;
  uint64_t pseudo_thread_id;

  plugin::StorageEngine *storage_engine;


  const charset_info_st *character_set_filesystem;


  const charset_info_st *collation_server;

  const charset_info_st* getCollation() const
  {
    return collation_server;
  }


  MY_LOCALE *lc_time_names;
};


}
# 39 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/temporal.h" 1
# 42 "./drizzled/temporal.h"
       
# 69 "./drizzled/temporal.h"
# 1 "./drizzled/calendar.h" 1
# 39 "./drizzled/calendar.h"
       
# 65 "./drizzled/calendar.h"
namespace drizzled
{




enum calendar
{
  GREGORIAN= 1,
  JULIAN= 2,
  HEBREW= 3,
  ISLAM= 4
};
# 93 "./drizzled/calendar.h"
int64_t julian_day_number_from_gregorian_date(uint32_t year, uint32_t month, uint32_t day);







int64_t absolute_day_number_to_julian_day_number(int64_t absolute_day);







int64_t julian_day_number_to_absolute_day_number(int64_t julian_day);
# 121 "./drizzled/calendar.h"
void gregorian_date_from_julian_day_number(int64_t julian_day
                                         , uint32_t *year_out
                                         , uint32_t *month_out
                                         , uint32_t *day_out);
# 136 "./drizzled/calendar.h"
void gregorian_date_from_absolute_day_number(int64_t absolute_day
                                           , uint32_t *year_out
                                           , uint32_t *month_out
                                           , uint32_t *day_out);







uint32_t days_in_year(uint32_t year, enum calendar calendar);






uint32_t days_in_year_gregorian(uint32_t year);






uint32_t days_in_year_julian(uint32_t year);
# 170 "./drizzled/calendar.h"
int32_t number_of_leap_years_julian(uint32_t year);
# 179 "./drizzled/calendar.h"
int32_t number_of_leap_years_gregorian(uint32_t year);
# 188 "./drizzled/calendar.h"
uint32_t days_in_gregorian_year_month(uint32_t year, uint32_t month);

inline static bool num_leap_years(uint32_t y, enum calendar c)
{
  return (c == GREGORIAN
          ? number_of_leap_years_gregorian(y)
          : number_of_leap_years_julian(y));
}
# 224 "./drizzled/calendar.h"
uint32_t day_of_week(int64_t day_number, bool sunday_is_first_day_of_week);
# 234 "./drizzled/calendar.h"
bool is_valid_gregorian_date(uint32_t year, uint32_t month, uint32_t day);
# 249 "./drizzled/calendar.h"
bool in_unix_epoch_range(uint32_t year
                       , uint32_t month
                       , uint32_t day
                       , uint32_t hour
                       , uint32_t minute
                       , uint32_t second);
# 269 "./drizzled/calendar.h"
uint32_t week_number_from_gregorian_date(uint32_t year
                                       , uint32_t month
                                       , uint32_t day
                                       , bool sunday_is_first_day_of_week);
# 290 "./drizzled/calendar.h"
uint32_t iso_week_number_from_gregorian_date(uint32_t year
                                           , uint32_t month
                                           , uint32_t day);






uint32_t year_month_to_months(uint32_t year_month);







uint32_t months_to_year_month(uint32_t months);
# 316 "./drizzled/calendar.h"
inline static bool is_leap_year(uint32_t y, enum calendar c)
{
  return (days_in_year(y, c) == 366);
}





inline static bool is_gregorian_leap_year(uint32_t y)
{
  return (days_in_year_gregorian(y) == 366);
}





inline static bool is_julian_leap_year(uint32_t y)
{
  return (days_in_year_julian(y) == 366);
}

}
# 70 "./drizzled/temporal.h" 2

# 1 "/usr/include/c++/4.8/cassert" 1 3
# 41 "/usr/include/c++/4.8/cassert" 3
       
# 42 "/usr/include/c++/4.8/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 43 "/usr/include/c++/4.8/cassert" 2 3
# 72 "./drizzled/temporal.h" 2


namespace drizzled {




class __attribute__ ((visibility("default"))) Temporal
{
protected:
  enum calendar _calendar;
  uint32_t _years;
  uint32_t _months;
  uint32_t _days;
  uint32_t _hours;
  uint32_t _minutes;
  uint32_t _seconds;
  time_t _epoch_seconds;
  uint32_t _useconds;
  uint32_t _nseconds;

  bool _overflow;

  uint64_t _cumulative_seconds_in_time() const;

  inline void _reset()
  {
    _years= _months= _days= _hours= _minutes=
      _seconds= _epoch_seconds= _useconds= _nseconds= 0;
  }

public:
  Temporal();
  virtual ~Temporal() {}


  inline enum calendar calendar() const {return _calendar;}

  inline void set_nseconds(const uint32_t nsecond) {_nseconds= nsecond;}

  inline uint32_t nseconds() const {return _nseconds;}

  inline void set_useconds(const uint32_t usecond) {_useconds= usecond;}

  inline uint32_t useconds() const {return _useconds;}




  void set_epoch_seconds();

  inline void set_epoch_seconds(const uint32_t epoch_second)
  {_epoch_seconds= epoch_second;}

  inline time_t epoch_seconds() const {return _epoch_seconds;}

  inline void set_seconds(const uint32_t second) {_seconds= second;}

  inline uint32_t seconds() const {return _seconds;}

  inline void set_minutes(const uint32_t minute) {_minutes= minute;}

  inline uint32_t minutes() const {return _minutes;}

  inline void set_hours(const uint32_t hour) {_hours= hour;}

  inline uint32_t hours() const {return _hours;}

  inline void set_days(const uint32_t day) {_days= day;}

  inline uint32_t days() const {return _days;}

  inline void set_months(const uint32_t month) {_months= month;}

  inline uint32_t months() const {return _months;}

  inline void set_years(const uint32_t year) {_years= year;}

  inline uint32_t years() const {return _years;}


  inline bool overflow() const {return _overflow;}


  virtual bool is_valid_date() const= 0;

  virtual bool is_valid_datetime() const= 0;

  virtual bool is_valid_time() const= 0;

  virtual bool is_valid_timestamp() const= 0;






  virtual bool is_valid() const= 0;
# 184 "./drizzled/temporal.h"
  friend class TemporalFormat;
};





class __attribute__ ((visibility("default"))) Date: public Temporal
{
public:
  Date() :Temporal() {}






  virtual bool operator==(const Date &rhs);
  virtual bool operator!=(const Date &rhs);
  virtual bool operator>(const Date &rhs);
  virtual bool operator>=(const Date &rhs);
  virtual bool operator<(const Date &rhs);
  virtual bool operator<=(const Date &rhs);







  virtual bool operator==(const DateTime &rhs);
  virtual bool operator!=(const DateTime &rhs);
  virtual bool operator>(const DateTime &rhs);
  virtual bool operator>=(const DateTime &rhs);
  virtual bool operator<(const DateTime &rhs);
  virtual bool operator<=(const DateTime &rhs);







  virtual bool operator==(const Timestamp &rhs);
  virtual bool operator!=(const Timestamp &rhs);
  virtual bool operator>(const Timestamp &rhs);
  virtual bool operator>=(const Timestamp &rhs);
  virtual bool operator<(const Timestamp &rhs);
  virtual bool operator<=(const Timestamp &rhs);
# 241 "./drizzled/temporal.h"
  const Date operator-(const Date &rhs);
  const Date operator+(const Date &rhs);
  Date& operator+=(const Date &rhs);
  Date& operator-=(const Date &rhs);







  const Date operator-(const Time &rhs);
  const Date operator+(const Time &rhs);
  Date& operator-=(const Time &rhs);
  Date& operator+=(const Time &rhs);
# 265 "./drizzled/temporal.h"
  const Date operator-(const DateTime &rhs);
  const Date operator+(const DateTime &rhs);
  Date& operator+=(const DateTime &rhs);
  Date& operator-=(const DateTime &rhs);
# 278 "./drizzled/temporal.h"
  Date& operator=(const DateTime &rhs);

  virtual bool is_valid_date() const {return is_valid();}
  virtual bool is_valid_datetime() const {return is_valid();}
  virtual bool is_valid_time() const {return false;}
  virtual bool is_valid_timestamp() const
  {
    return is_valid() && in_unix_epoch();
  }


  virtual bool is_valid() const;

  virtual bool in_unix_epoch() const;
# 304 "./drizzled/temporal.h"
  virtual int to_string(char *to, size_t to_len) const;





  static const int MAX_STRING_LENGTH= 11;
# 322 "./drizzled/temporal.h"
  virtual bool from_string(const char *from, size_t from_len);
# 331 "./drizzled/temporal.h"
  virtual void to_int64_t(int64_t *to) const;
# 340 "./drizzled/temporal.h"
  virtual void to_int32_t(int32_t *to) const;
# 351 "./drizzled/temporal.h"
  virtual bool from_int32_t(const int32_t from);
# 366 "./drizzled/temporal.h"
  void to_julian_day_number(int64_t *to) const;
# 377 "./drizzled/temporal.h"
  bool from_julian_day_number(const int64_t from);
# 386 "./drizzled/temporal.h"
  virtual void to_tm(struct tm *to) const;
# 398 "./drizzled/temporal.h"
  virtual bool from_tm(const struct tm *from);







  virtual void to_time_t(time_t &to) const;
# 417 "./drizzled/temporal.h"
  virtual bool from_time_t(const time_t from);







  virtual void to_decimal(type::Decimal *to) const;

  friend class TemporalInterval;
  friend class Timestamp;
};


class DateTime;





class __attribute__ ((visibility("default"))) Time: public Temporal
{
public:
  Time() :Temporal() {}

  static const uint32_t MAX_CUMULATIVE_SECONDS= 86400L;







  bool operator==(const Time &rhs);
  bool operator!=(const Time &rhs);
  bool operator>(const Time &rhs);
  bool operator>=(const Time &rhs);
  bool operator<(const Time &rhs);
  bool operator<=(const Time &rhs);






  const Time operator-(const Time &rhs);
  const Time operator+(const Time &rhs);
  Time& operator-=(const Time &rhs);
  Time& operator+=(const Time &rhs);

  bool is_valid_date() const {return false;}
  bool is_valid_datetime() const {return false;}
  bool is_valid_time() const {return is_valid();}
  bool is_valid_timestamp() const {return false;}


  bool is_valid() const;
  bool is_fuzzy_valid() const;
# 488 "./drizzled/temporal.h"
  int to_string(char *to, size_t to_len) const;





  static const int MAX_STRING_LENGTH= 9;
# 507 "./drizzled/temporal.h"
  bool from_string(const char *from, size_t from_len);
# 516 "./drizzled/temporal.h"
  void to_int32_t(int32_t *to) const;
# 525 "./drizzled/temporal.h"
  void to_uint64_t(uint64_t &to) const;
# 536 "./drizzled/temporal.h"
  bool from_int32_t(const int32_t from);
# 552 "./drizzled/temporal.h"
  bool from_time_t(const time_t from);







  void to_decimal(type::Decimal *to) const;

  friend class Date;
  friend class DateTime;
};





class __attribute__ ((visibility("default"))) DateTime: public Date
{
public:
  DateTime() :Date() {}

  friend class TemporalInterval;




  bool in_unix_epoch() const;

  virtual bool is_valid() const;





  void to_int32_t(int32_t *) const {((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/temporal.h", 588, __PRETTY_FUNCTION__));}
  bool from_int32_t(int32_t) {((0) ? static_cast<void> (0) : __assert_fail ("0", "./drizzled/temporal.h", 589, __PRETTY_FUNCTION__)); return false;}
# 602 "./drizzled/temporal.h"
  virtual int to_string(char *to, size_t to_len) const;





  static const int MAX_STRING_LENGTH= 27;
# 620 "./drizzled/temporal.h"
  bool from_string(const char *from, size_t from_len);
# 629 "./drizzled/temporal.h"
  void to_int64_t(int64_t *to) const;
# 640 "./drizzled/temporal.h"
  bool from_time_t(const time_t from);
  bool from_timeval(struct timeval &_timeval);
# 654 "./drizzled/temporal.h"
  bool from_int64_t(const int64_t from, bool convert);

  bool from_int64_t(const int64_t from) {
    return from_int64_t(from, true);
  }
# 667 "./drizzled/temporal.h"
  void to_tm(struct tm *to) const;







  void to_decimal(type::Decimal *to) const;

  friend class Timestamp;
};




class __attribute__ ((visibility("default"))) Timestamp: public DateTime
{
public:
  Timestamp() :DateTime() {}







  bool operator==(const Date &rhs);
  bool operator!=(const Date &rhs);
  bool operator>(const Date &rhs);
  bool operator>=(const Date &rhs);
  bool operator<(const Date &rhs);
  bool operator<=(const Date &rhs);







  bool operator==(const DateTime &rhs);
  bool operator!=(const DateTime &rhs);
  bool operator>(const DateTime &rhs);
  bool operator>=(const DateTime &rhs);
  bool operator<(const DateTime &rhs);
  bool operator<=(const DateTime &rhs);







  bool operator==(const Timestamp &rhs);
  bool operator!=(const Timestamp &rhs);
  bool operator>(const Timestamp &rhs);
  bool operator>=(const Timestamp &rhs);
  bool operator<(const Timestamp &rhs);
  bool operator<=(const Timestamp &rhs);

  bool is_valid_timestamp() const {return is_valid();}

  virtual bool is_valid() const;







  void to_time_t(time_t &to) const;
};




std::ostream& operator<<(std::ostream& os, const Timestamp& subject);





class __attribute__ ((visibility("default"))) MicroTimestamp: public Timestamp
{
public:
  MicroTimestamp() :Timestamp() {}

  bool is_valid() const;
# 767 "./drizzled/temporal.h"
  int to_string(char *to, size_t to_len) const;





  static const int MAX_STRING_LENGTH= 27;
# 785 "./drizzled/temporal.h"
  void to_timeval(struct timeval &to) const;
};





class __attribute__ ((visibility("default"))) NanoTimestamp: public Timestamp
{
public:
  NanoTimestamp() :Timestamp() {}

  bool is_valid() const;
# 809 "./drizzled/temporal.h"
  void to_timespec(struct timespec *to) const;
};

}
# 40 "drizzled/item/cmpfunc.cc" 2
# 1 "./drizzled/time_functions.h" 1
# 20 "./drizzled/time_functions.h"
       




namespace drizzled
{


int calc_weekday(long daynr, bool sunday_first_day_of_week);
# 59 "./drizzled/time_functions.h"
uint32_t calc_week(type::Time *l_time, uint32_t week_behaviour, uint32_t *year);



void get_date_from_daynr(long daynr,
                         uint32_t *year,
                         uint32_t *month,
                         uint32_t *day);
# 75 "./drizzled/time_functions.h"
type::timestamp_t str_to_datetime_with_warn(Session&, str_ref, type::Time&, uint32_t flags);
# 84 "./drizzled/time_functions.h"
bool str_to_time_with_warn(Session&, str_ref, type::Time&);

void make_truncated_value_warning(Session&, DRIZZLE_ERROR::enum_warning_level level, str_ref, type::timestamp_t, const char* field);
# 113 "./drizzled/time_functions.h"
bool calc_time_diff(type::Time *l_time1,
                    type::Time *l_time2,
                    int l_sign,
                    int64_t *seconds_out,
                    long *microseconds_out);

}
# 41 "drizzled/item/cmpfunc.cc" 2




using namespace std;

namespace drizzled {

extern const double log_10[309];

static Eq_creator eq_creator;
static Ne_creator ne_creator;
static Gt_creator gt_creator;
static Lt_creator lt_creator;
static Ge_creator ge_creator;
static Le_creator le_creator;

static bool convert_constant_item(Session *, Item_field *, Item **);

static Item_result item_store_type(Item_result a, Item *item,
                                   bool unsigned_flag)
{
  Item_result b= item->result_type();

  if (a == STRING_RESULT || b == STRING_RESULT)
    return STRING_RESULT;
  else if (a == REAL_RESULT || b == REAL_RESULT)
    return REAL_RESULT;
  else if (a == DECIMAL_RESULT || b == DECIMAL_RESULT ||
           unsigned_flag != item->unsigned_flag)
    return DECIMAL_RESULT;
  else
    return INT_RESULT;
}

static void agg_result_type(Item_result *type, Item **items, uint32_t nitems)
{
  Item **item, **item_end;
  bool unsigned_flag= 0;

  *type= STRING_RESULT;

  for (item= items, item_end= item + nitems; item < item_end; item++)
  {
    if ((*item)->type() != Item::NULL_ITEM)
    {
      *type= (*item)->result_type();
      unsigned_flag= (*item)->unsigned_flag;
      item++;
      break;
    }
  }

  for (; item < item_end; item++)
  {
    if ((*item)->type() != Item::NULL_ITEM)
    {
      *type= item_store_type(*type, *item, unsigned_flag);
    }
  }
}
# 124 "drizzled/item/cmpfunc.cc"
static int cmp_row_type(Item* item1, Item* item2)
{
  uint32_t n= item1->cols();
  if (item2->check_cols(n))
    return 1;
  for (uint32_t i=0; i<n; i++)
  {
    if (item2->element_index(i)->check_cols(item1->element_index(i)->cols()) ||
        (item1->element_index(i)->result_type() == ROW_RESULT &&
         cmp_row_type(item1->element_index(i), item2->element_index(i))))
      return 1;
  }
  return 0;
}
# 163 "drizzled/item/cmpfunc.cc"
static int agg_cmp_type(Item_result *type, Item **items, uint32_t nitems)
{
  uint32_t i;
  type[0]= items[0]->result_type();
  for (i= 1 ; i < nitems ; i++)
  {
    type[0]= item_cmp_type(type[0], items[i]->result_type());







    if (type[0] == ROW_RESULT && cmp_row_type(items[0], items[i]))
      return 1;
  }
  return 0;
}
# 202 "drizzled/item/cmpfunc.cc"
enum_field_types agg_field_type(Item **items, uint32_t nitems)
{
  uint32_t i;
  if (!nitems || items[0]->result_type() == ROW_RESULT )
    return (enum_field_types)-1;
  enum_field_types res= items[0]->field_type();
  for (i= 1 ; i < nitems ; i++)
    res= Field::field_type_merge(res, items[i]->field_type());
  return res;
}
# 231 "drizzled/item/cmpfunc.cc"
static uint32_t collect_cmp_types(Item **items, uint32_t nitems, bool skip_nulls= false)
{
  uint32_t i;
  uint32_t found_types;
  Item_result left_result= items[0]->result_type();
  ((nitems > 1) ? static_cast<void> (0) : __assert_fail ("nitems > 1", "drizzled/item/cmpfunc.cc", 236, __PRETTY_FUNCTION__));
  found_types= 0;
  for (i= 1; i < nitems ; i++)
  {
    if (skip_nulls && items[i]->type() == Item::NULL_ITEM)
      continue;
    if ((left_result == ROW_RESULT ||
         items[i]->result_type() == ROW_RESULT) &&
        cmp_row_type(items[0], items[i]))
      return 0;
    found_types|= 1<< (uint32_t)item_cmp_type(left_result,
                                           items[i]->result_type());
  }




  if (skip_nulls && !found_types)
    found_types= 1 << (uint)left_result;
  return found_types;
}


Item_bool_func2* Eq_creator::create(Item *a, Item *b) const
{
  return new Item_func_eq(a, b);
}


const Eq_creator* Eq_creator::instance()
{
  return &eq_creator;
}


Item_bool_func2* Ne_creator::create(Item *a, Item *b) const
{
  return new Item_func_ne(a, b);
}


const Ne_creator* Ne_creator::instance()
{
  return &ne_creator;
}


Item_bool_func2* Gt_creator::create(Item *a, Item *b) const
{
  return new Item_func_gt(a, b);
}


const Gt_creator* Gt_creator::instance()
{
  return &gt_creator;
}


Item_bool_func2* Lt_creator::create(Item *a, Item *b) const
{
  return new Item_func_lt(a, b);
}


const Lt_creator* Lt_creator::instance()
{
  return &lt_creator;
}


Item_bool_func2* Ge_creator::create(Item *a, Item *b) const
{
  return new Item_func_ge(a, b);
}


const Ge_creator* Ge_creator::instance()
{
  return &ge_creator;
}


Item_bool_func2* Le_creator::create(Item *a, Item *b) const
{
  return new Item_func_le(a, b);
}

const Le_creator* Le_creator::instance()
{
  return &le_creator;
}
# 336 "drizzled/item/cmpfunc.cc"
int64_t Item_func_not::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 338, __PRETTY_FUNCTION__));
  bool value= args[0]->val_bool();
  null_value=args[0]->null_value;
  return ((!null_value && value == 0) ? 1 : 0);
}
# 353 "drizzled/item/cmpfunc.cc"
void Item_func_not::print(String *str)
{
  str->append('(');
  Item_func::print(str);
  str->append(')');
}






int64_t Item_func_not_all::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 367, __PRETTY_FUNCTION__));
  bool value= args[0]->val_bool();





  if (empty_underlying_subquery())
    return 1;

  null_value= args[0]->null_value;
  return ((!null_value && value == 0) ? 1 : 0);
}


bool Item_func_not_all::empty_underlying_subquery()
{
  return ((test_sum_item && !test_sum_item->any_value()) ||
          (test_sub_item && !test_sub_item->any_value()));
}

void Item_func_not_all::print(String *str)
{
  if (show)
    Item_func::print(str);
  else
    args[0]->print(str);
}
# 406 "drizzled/item/cmpfunc.cc"
int64_t Item_func_nop_all::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 408, __PRETTY_FUNCTION__));
  int64_t value= args[0]->val_int();





  if (empty_underlying_subquery())
    return 0;

  null_value= args[0]->null_value;
  return (null_value || value == 0) ? 0 : 1;
}
# 450 "drizzled/item/cmpfunc.cc"
static bool convert_constant_item(Session *session, Item_field *field_item,
                                  Item **item)
{
  Field *field= field_item->field;
  int result= 0;

  field->setWriteSet();

  if (!(*item)->with_subselect && (*item)->const_item())
  {
    ulong orig_sql_mode= session->variables.sql_mode;
    enum_check_fields orig_count_cuted_fields= session->count_cuted_fields;
    uint64_t orig_field_val= 0;


    session->variables.sql_mode= (orig_sql_mode & ~(2)) |
                             ((2)*2);
    session->count_cuted_fields= CHECK_FIELD_IGNORE;





    if (field_item->depended_from)
    {
      orig_field_val= field->val_int();
    }

    if (!(*item)->is_null() && !(*item)->save_in_field(field, 1))
    {
      Item *tmp= new Item_int_with_ref(field->val_int(), *item,
                                       test(field->flags & 32));
      if (tmp)
        *item= tmp;
      result= 1;
    }


    if (field_item->depended_from)
    {
      result= field->store(orig_field_val, field->isUnsigned());

      ((!result) ? static_cast<void> (0) : __assert_fail ("!result", "drizzled/item/cmpfunc.cc", 492, __PRETTY_FUNCTION__));
    }
    session->variables.sql_mode= orig_sql_mode;
    session->count_cuted_fields= orig_count_cuted_fields;
  }
  return result;
}


void Item_bool_func2::fix_length_and_dec()
{
  max_length= 1;





  if (!args[0] || !args[1])
    return;
# 525 "drizzled/item/cmpfunc.cc"
  DTCollation coll;
  if (args[0]->result_type() == STRING_RESULT &&
      args[1]->result_type() == STRING_RESULT &&
      agg_arg_charsets(coll, args, 2, 7, 1))
    return;

  args[0]->cmp_context= args[1]->cmp_context=
    item_cmp_type(args[0]->result_type(), args[1]->result_type());


  if (functype() == LIKE_FUNC)
  {
    set_cmp_func();
    return;
  }

  Item_field *field_item= __null;

  if (args[0]->real_item()->type() == FIELD_ITEM)
  {
    field_item= static_cast<Item_field*>(args[0]->real_item());
    if (field_item->field->can_be_compared_as_int64_t() &&
        !(field_item->is_datetime() && args[1]->result_type() == STRING_RESULT))
    {
      if (convert_constant_item(&getSession(), field_item, &args[1]))
      {
        cmp.set_cmp_func(this, tmp_arg, tmp_arg+1,
                         INT_RESULT);
        args[0]->cmp_context= args[1]->cmp_context= INT_RESULT;
        return;
      }
    }

    if (args[1]->real_item()->type() == FIELD_ITEM)
    {
      field_item= static_cast<Item_field*>(args[1]->real_item());
      if (field_item->field->can_be_compared_as_int64_t() &&
          !(field_item->is_datetime() &&
            args[0]->result_type() == STRING_RESULT))
      {
        if (convert_constant_item(&getSession(), field_item, &args[0]))
        {
          cmp.set_cmp_func(this, tmp_arg, tmp_arg+1,
                           INT_RESULT);
          args[0]->cmp_context= args[1]->cmp_context= INT_RESULT;
          return;
        }
      }
    }
  }
  set_cmp_func();
}

Arg_comparator::Arg_comparator():
  session(::drizzled::_current_session()),
  a_cache(0),
  b_cache(0)
{}

Arg_comparator::Arg_comparator(Item **a1, Item **a2):
  a(a1),
  b(a2),
  session(::drizzled::_current_session()),
  a_cache(0),
  b_cache(0)
{}

int Arg_comparator::set_compare_func(Item_bool_func2 *item, Item_result type)
{
  owner= item;
  func= comparator_matrix[type]
    [test(owner->functype() == Item_func::EQUAL_FUNC)];

  switch (type) {
  case ROW_RESULT:
    {
      uint32_t n= (*a)->cols();
      if (n != (*b)->cols())
      {
        my_error(ER_OPERAND_COLUMNS, (static_cast<drizzled::myf>(0)), n);
        comparators= 0;
        return 1;
      }
      comparators= new Arg_comparator[n];
      for (uint32_t i=0; i < n; i++)
      {
        if ((*a)->element_index(i)->cols() != (*b)->element_index(i)->cols())
        {
          my_error(ER_OPERAND_COLUMNS, (static_cast<drizzled::myf>(0)), (*a)->element_index(i)->cols());
          return 1;
        }
        comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
      }
      break;
    }

  case STRING_RESULT:
    {




      if (cmp_collation.set((*a)->collation, (*b)->collation) ||
          cmp_collation.derivation == DERIVATION_NONE)
      {
        my_coll_agg_error((*a)->collation, (*b)->collation, owner->func_name());
        return 1;
      }
      if (cmp_collation.collation == &my_charset_bin)
      {




        if (func == &Arg_comparator::compare_string)
          func= &Arg_comparator::compare_binary_string;
        else if (func == &Arg_comparator::compare_e_string)
          func= &Arg_comparator::compare_e_binary_string;
# 652 "drizzled/item/cmpfunc.cc"
        (*a)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
        (*b)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
      }
      break;
    }
  case INT_RESULT:
    {
      if (func == &Arg_comparator::compare_int_signed)
      {
        if ((*a)->unsigned_flag)
          func= (((*b)->unsigned_flag)?
                 &Arg_comparator::compare_int_unsigned :
                 &Arg_comparator::compare_int_unsigned_signed);
        else if ((*b)->unsigned_flag)
          func= &Arg_comparator::compare_int_signed_unsigned;
      }
      else if (func== &Arg_comparator::compare_e_int)
      {
        if ((*a)->unsigned_flag ^ (*b)->unsigned_flag)
          func= &Arg_comparator::compare_e_int_diff_signedness;
      }
      break;
    }
  case DECIMAL_RESULT:
    break;
  case REAL_RESULT:
    {
      if ((*a)->decimals < (uint8_t)31 && (*b)->decimals < (uint8_t)31)
      {
        precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
        if (func == &Arg_comparator::compare_real)
          func= &Arg_comparator::compare_real_fixed;
        else if (func == &Arg_comparator::compare_e_real)
          func= &Arg_comparator::compare_e_real_fixed;
      }
      break;
    }
  }

  return 0;
}
# 717 "drizzled/item/cmpfunc.cc"
static int64_t
get_date_from_str(Session *session, String *str, type::timestamp_t warn_type, const char *warn_name, bool *error_arg)
{
  int64_t value= 0;
  type::cut_t error= type::VALID;
  type::Time l_time;
  type::timestamp_t ret;

  ret= l_time.store(str->ptr(), str->length(),
                    (1 | ((2)*2) | (session->variables.sql_mode & (2))),
                    error);

  if (ret == type::DRIZZLE_TIMESTAMP_DATETIME || ret == type::DRIZZLE_TIMESTAMP_DATE)
  {




    *error_arg= false;
    l_time.convert(value);
  }
  else
  {
    *error_arg= true;
    error= type::CUT;
  }

  if (error != type::VALID)
  {
    make_truncated_value_warning(*session, DRIZZLE_ERROR::WARN_LEVEL_WARN, *str, warn_type, warn_name);
  }

  return value;
}
# 785 "drizzled/item/cmpfunc.cc"
enum Arg_comparator::enum_date_cmp_type
Arg_comparator::can_compare_as_dates(Item *in_a, Item *in_b,
                                     int64_t *const_value)
{
  enum enum_date_cmp_type cmp_type= CMP_DATE_DFLT;
  Item *str_arg= 0;

  if (in_a->type() == Item::ROW_ITEM || in_b->type() == Item::ROW_ITEM)
    return CMP_DATE_DFLT;

  if (in_a->is_datetime())
  {
    if (in_b->is_datetime())
    {
      cmp_type= CMP_DATE_WITH_DATE;
    }
    else if (in_b->result_type() == STRING_RESULT)
    {
      cmp_type= CMP_DATE_WITH_STR;
      str_arg= in_b;
    }
  }
  else if (in_b->is_datetime() && in_a->result_type() == STRING_RESULT)
  {
    cmp_type= CMP_STR_WITH_DATE;
    str_arg= in_a;
  }

  if (cmp_type != CMP_DATE_DFLT)
  {




    if (cmp_type != CMP_DATE_WITH_DATE && str_arg->const_item() &&
        (str_arg->type() != Item::FUNC_ITEM ||
        ((Item_func*)str_arg)->functype() != Item_func::GUSERVAR_FUNC))
    {
# 840 "drizzled/item/cmpfunc.cc"
      int64_t value;
      String *str_val;
      String tmp;

      DateTime temporal;

      str_val= str_arg->val_str(&tmp);
      if (! str_val)
      {







        return CMP_DATE_DFLT;
      }
      if (temporal.from_string(str_val->c_ptr(), str_val->length()))
      {

        temporal.to_int64_t(&value);
      }
      else
      {

        Time timevalue;
        if (timevalue.from_string(str_val->c_ptr(), str_val->length()))
        {
          uint64_t timeint;
          timevalue.to_uint64_t(timeint);
          value= static_cast<int64_t>(timeint);
        }
        else
        {

          my_error(ER_INVALID_DATETIME_VALUE, (static_cast<drizzled::myf>(1024)), str_val->c_ptr());
          return CMP_DATE_DFLT;
        }
      }

      if (const_value)
        *const_value= value;
    }
  }
  return cmp_type;
}


int Arg_comparator::set_cmp_func(Item_bool_func2 *owner_arg,
                                        Item **a1, Item **a2,
                                        Item_result type)
{
  enum_date_cmp_type cmp_type;
  int64_t const_value= -1;
  a= a1;
  b= a2;

  if ((cmp_type= can_compare_as_dates(*a, *b, &const_value)))
  {
    owner= owner_arg;
    a_type= (*a)->field_type();
    b_type= (*b)->field_type();
    a_cache= 0;
    b_cache= 0;

    if (const_value != -1)
    {
      Item_cache_int *cache= new Item_cache_int();

      cache->set_used_tables(1);
      if (!(*a)->is_datetime())
      {
        cache->store((*a), const_value);
        a_cache= cache;
        a= (Item **)&a_cache;
      }
      else
      {
        cache->store((*b), const_value);
        b_cache= cache;
        b= (Item **)&b_cache;
      }
    }
    is_nulls_eq= test(owner && owner->functype() == Item_func::EQUAL_FUNC);
    func= &Arg_comparator::compare_datetime;
    get_value_func= &get_datetime_value;

    return 0;
  }

  return set_compare_func(owner_arg, type);
}


void Arg_comparator::set_datetime_cmp_func(Item **a1, Item **b1)
{

  owner= __null;
  a= a1;
  b= b1;
  a_type= (*a)->field_type();
  b_type= (*b)->field_type();
  a_cache= 0;
  b_cache= 0;
  is_nulls_eq= false;
  func= &Arg_comparator::compare_datetime;
  get_value_func= &get_datetime_value;
}
# 980 "drizzled/item/cmpfunc.cc"
int64_t
get_datetime_value(Session *session, Item ***item_arg, Item **cache_arg,
                   Item *warn_item, bool *is_null)
{
  int64_t value= 0;
  String buf, *str= 0;
  Item *item= **item_arg;

  if (item->result_as_int64_t())
  {
    value= item->val_int();
    *is_null= item->null_value;
    enum_field_types f_type= item->field_type();






    if (f_type == DRIZZLE_TYPE_DATE ||
        (f_type != DRIZZLE_TYPE_DATETIME && value < 100000000L))
      value*= 1000000L;
  }
  else
  {
    str= item->val_str(&buf);
    *is_null= item->null_value;
  }

  if (*is_null)
    return ~(uint64_t) 0;







  if (str)
  {
    bool error;
    enum_field_types f_type= warn_item->field_type();
    type::timestamp_t t_type= f_type == DRIZZLE_TYPE_DATE ? type::DRIZZLE_TIMESTAMP_DATE : type::DRIZZLE_TIMESTAMP_DATETIME;
    value= get_date_from_str(session, str, t_type, warn_item->name, &error);






  }




  if (item->const_item() && cache_arg && (item->type() != Item::FUNC_ITEM ||
      ((Item_func*)item)->functype() != Item_func::GUSERVAR_FUNC))
  {
    Item_cache_int *cache= new Item_cache_int(DRIZZLE_TYPE_DATETIME);

    cache->set_used_tables(1);
    cache->store(item, value);
    *cache_arg= cache;
    *item_arg= cache_arg;
  }

  return value;
}
# 1070 "drizzled/item/cmpfunc.cc"
int Arg_comparator::compare_datetime()
{
  bool is_null= false;
  uint64_t a_value, b_value;


  a_value= (*get_value_func)(session, &a, &a_cache, *b, &is_null);
  if (!is_nulls_eq && is_null)
  {
    if (owner)
      owner->null_value= 1;
    return -1;
  }


  b_value= (*get_value_func)(session, &b, &b_cache, *a, &is_null);
  if (is_null)
  {
    if (owner)
      owner->null_value= is_nulls_eq ? 0 : 1;
    return is_nulls_eq ? 1 : -1;
  }

  if (owner)
    owner->null_value= 0;


  if (is_nulls_eq)
    return (a_value == b_value);
  return (a_value < b_value) ? -1 : ((a_value > b_value) ? 1 : 0);
}


int Arg_comparator::compare_string()
{
  String *res1,*res2;
  if ((res1= (*a)->val_str(&owner->tmp_value1)))
  {
    if ((res2= (*b)->val_str(&owner->tmp_value2)))
    {
      owner->null_value= 0;
      return sortcmp(res1,res2,cmp_collation.collation);
    }
  }
  owner->null_value= 1;
  return -1;
}
# 1130 "drizzled/item/cmpfunc.cc"
int Arg_comparator::compare_binary_string()
{
  String *res1,*res2;
  if ((res1= (*a)->val_str(&owner->tmp_value1)))
  {
    if ((res2= (*b)->val_str(&owner->tmp_value2)))
    {
      owner->null_value= 0;
      uint32_t res1_length= res1->length();
      uint32_t res2_length= res2->length();
      int cmp= memcmp(res1->ptr(), res2->ptr(), min(res1_length,res2_length));
      return cmp ? cmp : (int) (res1_length - res2_length);
    }
  }
  owner->null_value= 1;
  return -1;
}







int Arg_comparator::compare_e_string()
{
  String *res1,*res2;
  res1= (*a)->val_str(&owner->tmp_value1);
  res2= (*b)->val_str(&owner->tmp_value2);
  if (!res1 || !res2)
    return test(res1 == res2);
  return test(sortcmp(res1, res2, cmp_collation.collation) == 0);
}


int Arg_comparator::compare_e_binary_string()
{
  String *res1,*res2;
  res1= (*a)->val_str(&owner->tmp_value1);
  res2= (*b)->val_str(&owner->tmp_value2);
  if (!res1 || !res2)
    return test(res1 == res2);
  return test(stringcmp(res1, res2) == 0);
}


int Arg_comparator::compare_real()
{





  volatile double val1, val2;
  val1= (*a)->val_real();
  if (!(*a)->null_value)
  {
    val2= (*b)->val_real();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (val1 < val2) return -1;
      if (val1 == val2) return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}

int Arg_comparator::compare_decimal()
{
  type::Decimal value1;
  type::Decimal *val1= (*a)->val_decimal(&value1);
  if (!(*a)->null_value)
  {
    type::Decimal value2;
    type::Decimal *val2= (*b)->val_decimal(&value2);
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      return class_decimal_cmp(val1, val2);
    }
  }
  owner->null_value= 1;
  return -1;
}

int Arg_comparator::compare_e_real()
{
  double val1= (*a)->val_real();
  double val2= (*b)->val_real();
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return test(val1 == val2);
}

int Arg_comparator::compare_e_decimal()
{
  type::Decimal value1, value2;
  type::Decimal *val1= (*a)->val_decimal(&value1);
  type::Decimal *val2= (*b)->val_decimal(&value2);
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return test(class_decimal_cmp(val1, val2) == 0);
}


int Arg_comparator::compare_real_fixed()
{





  volatile double val1, val2;
  val1= (*a)->val_real();
  if (!(*a)->null_value)
  {
    val2= (*b)->val_real();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (val1 == val2 || fabs(val1 - val2) < precision)
        return 0;
      if (val1 < val2)
        return -1;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}


int Arg_comparator::compare_e_real_fixed()
{
  double val1= (*a)->val_real();
  double val2= (*b)->val_real();
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return test(val1 == val2 || fabs(val1 - val2) < precision);
}


int Arg_comparator::compare_int_signed()
{
  int64_t val1= (*a)->val_int();
  if (!(*a)->null_value)
  {
    int64_t val2= (*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (val1 < val2) return -1;
      if (val1 == val2) return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}






int Arg_comparator::compare_int_unsigned()
{
  uint64_t val1= (*a)->val_int();
  if (!(*a)->null_value)
  {
    uint64_t val2= (*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (val1 < val2) return -1;
      if (val1 == val2) return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}






int Arg_comparator::compare_int_signed_unsigned()
{
  int64_t sval1= (*a)->val_int();
  if (!(*a)->null_value)
  {
    uint64_t uval2= (uint64_t)(*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (sval1 < 0 || (uint64_t)sval1 < uval2)
        return -1;
      if ((uint64_t)sval1 == uval2)
        return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}






int Arg_comparator::compare_int_unsigned_signed()
{
  uint64_t uval1= (uint64_t)(*a)->val_int();
  if (!(*a)->null_value)
  {
    int64_t sval2= (*b)->val_int();
    if (!(*b)->null_value)
    {
      owner->null_value= 0;
      if (sval2 < 0)
        return 1;
      if (uval1 < (uint64_t)sval2)
        return -1;
      if (uval1 == (uint64_t)sval2)
        return 0;
      return 1;
    }
  }
  owner->null_value= 1;
  return -1;
}


int Arg_comparator::compare_e_int()
{
  int64_t val1= (*a)->val_int();
  int64_t val2= (*b)->val_int();
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return test(val1 == val2);
}




int Arg_comparator::compare_e_int_diff_signedness()
{
  int64_t val1= (*a)->val_int();
  int64_t val2= (*b)->val_int();
  if ((*a)->null_value || (*b)->null_value)
    return test((*a)->null_value && (*b)->null_value);
  return (val1 >= 0) && test(val1 == val2);
}

int Arg_comparator::compare_row()
{
  int res= 0;
  bool was_null= 0;
  (*a)->bring_value();
  (*b)->bring_value();
  uint32_t n= (*a)->cols();
  for (uint32_t i= 0; i<n; i++)
  {
    res= comparators[i].compare();
    if (owner->null_value)
    {

      switch (owner->functype()) {
      case Item_func::NE_FUNC:
        break;
      case Item_func::LT_FUNC:
      case Item_func::LE_FUNC:
      case Item_func::GT_FUNC:
      case Item_func::GE_FUNC:
        return -1;
      default:
        if (owner->abort_on_null)
          return -1;
      }
      was_null= 1;
      owner->null_value= 0;
      res= 0;
    }
    else if (res)
      return res;
  }
  if (was_null)
  {




    owner->null_value= 1;
    return -1;
  }
  return 0;
}


int Arg_comparator::compare_e_row()
{
  (*a)->bring_value();
  (*b)->bring_value();
  uint32_t n= (*a)->cols();
  for (uint32_t i= 0; i<n; i++)
  {
    if (!comparators[i].compare())
      return 0;
  }
  return 1;
}


void Item_func_truth::fix_length_and_dec()
{
  maybe_null= 0;
  null_value= 0;
  decimals= 0;
  max_length= 1;
}


void Item_func_truth::print(String *str)
{
  str->append('(');
  args[0]->print(str);
  str->append((" is "), (sizeof(" is ") - 1));
  if (! affirmative)
    str->append(("not "), (sizeof("not ") - 1));
  if (value)
    str->append(("true"), (sizeof("true") - 1));
  else
    str->append(("false"), (sizeof("false") - 1));
  str->append(')');
}


bool Item_func_truth::val_bool()
{
  bool val= args[0]->val_bool();
  if (args[0]->null_value)
  {




    return (! affirmative);
  }

  if (affirmative)
  {

    return (val == value);
  }


  return (val != value);
}


int64_t Item_func_truth::val_int()
{
  return (val_bool() ? 1 : 0);
}


bool Item_in_optimizer::fix_left(Session *session, Item **)
{
  if ((!args[0]->fixed && args[0]->fix_fields(session, args)) ||
      (!cache && !(cache= Item_cache::get_cache(args[0]))))
    return 1;

  cache->setup(args[0]);
  if (cache->cols() == 1)
  {
    if ((used_tables_cache= args[0]->used_tables()))
      cache->set_used_tables((((table_map) 1) << (sizeof(table_map)*8-2)));
    else
      cache->set_used_tables(0);
  }
  else
  {
    uint32_t n= cache->cols();
    for (uint32_t i= 0; i < n; i++)
    {
      if (args[0]->element_index(i)->used_tables())
 ((Item_cache *)cache->element_index(i))->set_used_tables((((table_map) 1) << (sizeof(table_map)*8-2)));
      else
 ((Item_cache *)cache->element_index(i))->set_used_tables(0);
    }
    used_tables_cache= args[0]->used_tables();
  }
  not_null_tables_cache= args[0]->not_null_tables();
  with_sum_func= args[0]->with_sum_func;
  if ((const_item_cache= args[0]->const_item()))
    cache->store(args[0]);
  return 0;
}


bool Item_in_optimizer::fix_fields(Session *session, Item **ref)
{
  ((fixed == 0) ? static_cast<void> (0) : __assert_fail ("fixed == 0", "drizzled/item/cmpfunc.cc", 1538, __PRETTY_FUNCTION__));
  if (fix_left(session, ref))
    return true;
  if (args[0]->maybe_null)
    maybe_null=1;

  if (!args[1]->fixed && args[1]->fix_fields(session, args+1))
    return true;
  Item_in_subselect * sub= (Item_in_subselect *)args[1];
  if (args[0]->cols() != sub->engine->cols())
  {
    my_error(ER_OPERAND_COLUMNS, (static_cast<drizzled::myf>(0)), args[0]->cols());
    return true;
  }
  if (args[1]->maybe_null)
    maybe_null=1;
  with_sum_func= with_sum_func || args[1]->with_sum_func;
  used_tables_cache|= args[1]->used_tables();
  not_null_tables_cache|= args[1]->not_null_tables();
  const_item_cache&= args[1]->const_item();
  fixed= 1;
  return false;
}


int64_t Item_in_optimizer::val_int()
{
  bool tmp;
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1566, __PRETTY_FUNCTION__));
  cache->store(args[0]);

  if (cache->null_value)
  {
    if (((Item_in_subselect*)args[1])->is_top_level_item())
    {




      null_value= 1;
    }
    else
    {
      if (!((Item_in_subselect*)args[1])->is_correlated &&
          result_for_null_param != ((bool)-1))
      {

        null_value= result_for_null_param;
      }
      else
      {







        Item_in_subselect *item_subs=(Item_in_subselect*)args[1];
        if (cache->cols() == 1)
        {
          item_subs->set_cond_guard_var(0, false);
          (void) args[1]->val_bool_result();
          result_for_null_param= null_value= !item_subs->engine->no_rows();
          item_subs->set_cond_guard_var(0, true);
        }
        else
        {
          uint32_t i;
          uint32_t ncols= cache->cols();




          for (i= 0; i < ncols; i++)
          {
            if (cache->element_index(i)->null_value)
              item_subs->set_cond_guard_var(i, false);
          }

          (void) args[1]->val_bool_result();
          result_for_null_param= null_value= !item_subs->engine->no_rows();


          for (i= 0; i < ncols; i++)
            item_subs->set_cond_guard_var(i, true);
        }
      }
    }
    return 0;
  }
  tmp= args[1]->val_bool_result();
  null_value= args[1]->null_value;
  return tmp;
}


void Item_in_optimizer::keep_top_level_cache()
{
  cache->keep_array();
  save_cache= 1;
}


void Item_in_optimizer::cleanup()
{
  item::function::Boolean::cleanup();
  if (!save_cache)
    cache= 0;
  return;
}


bool Item_in_optimizer::is_null()
{
  cache->store(args[0]);
  return (null_value= (cache->null_value || args[1]->is_null()));
}
# 1680 "drizzled/item/cmpfunc.cc"
Item *Item_in_optimizer::transform(Item_transformer transformer, unsigned char *argument)
{
  Item *new_item;

  ((arg_count == 2) ? static_cast<void> (0) : __assert_fail ("arg_count == 2", "drizzled/item/cmpfunc.cc", 1684, __PRETTY_FUNCTION__));


  new_item= (*args)->transform(transformer, argument);
  if (!new_item)
    return 0;
  *args= new_item;
# 1699 "drizzled/item/cmpfunc.cc"
  (((args[1])->type() == Item::SUBSELECT_ITEM && (((Item_subselect*)(args[1]))->substype() == Item_subselect::IN_SUBS || ((Item_subselect*)(args[1]))->substype() == Item_subselect::ALL_SUBS || ((Item_subselect*)(args[1]))->substype() == Item_subselect::ANY_SUBS)) ? static_cast<void> (0) : __assert_fail ("(args[1])->type() == Item::SUBSELECT_ITEM && (((Item_subselect*)(args[1]))->substype() == Item_subselect::IN_SUBS || ((Item_subselect*)(args[1]))->substype() == Item_subselect::ALL_SUBS || ((Item_subselect*)(args[1]))->substype() == Item_subselect::ANY_SUBS)",





 "drizzled/item/cmpfunc.cc"
# 1699 "drizzled/item/cmpfunc.cc" 3 4
  ,





 1705
# 1699 "drizzled/item/cmpfunc.cc" 3 4
  , __PRETTY_FUNCTION__))





                                         ;

  Item_in_subselect *in_arg= (Item_in_subselect*)args[1];
  in_arg->left_expr= args[0];

  return (this->*transformer)(argument);
}



int64_t Item_func_eq::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1717, __PRETTY_FUNCTION__));
  int value= cmp.compare();
  return value == 0 ? 1 : 0;
}




void Item_func_equal::fix_length_and_dec()
{
  Item_bool_func2::fix_length_and_dec();
  maybe_null=null_value=0;
}

int64_t Item_func_equal::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1733, __PRETTY_FUNCTION__));
  return cmp.compare();
}

int64_t Item_func_ne::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1739, __PRETTY_FUNCTION__));
  int value= cmp.compare();
  return value != 0 && !null_value ? 1 : 0;
}


int64_t Item_func_ge::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1747, __PRETTY_FUNCTION__));
  int value= cmp.compare();
  return value >= 0 ? 1 : 0;
}


int64_t Item_func_gt::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1755, __PRETTY_FUNCTION__));
  int value= cmp.compare();
  return value > 0 ? 1 : 0;
}

int64_t Item_func_le::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1762, __PRETTY_FUNCTION__));
  int value= cmp.compare();
  return value <= 0 && !null_value ? 1 : 0;
}


int64_t Item_func_lt::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1770, __PRETTY_FUNCTION__));
  int value= cmp.compare();
  return value < 0 && !null_value ? 1 : 0;
}


int64_t Item_func_strcmp::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1778, __PRETTY_FUNCTION__));
  String *a=args[0]->val_str(&tmp_value1);
  String *b=args[1]->val_str(&tmp_value2);
  if (!a || !b)
  {
    null_value=1;
    return 0;
  }
  int value= sortcmp(a,b,cmp.cmp_collation.collation);
  null_value=0;
  return !value ? 0 : (value < 0 ? (int64_t) -1 : (int64_t) 1);
}


bool Item_func_opt_neg::eq(const Item *item, bool binary_cmp) const
{

  if (this == item)
    return 1;
  if (item->type() != FUNC_ITEM)
    return 0;
  Item_func *item_func=(Item_func*) item;
  if (arg_count != item_func->arg_count ||
      functype() != item_func->functype())
    return 0;
  if (negated != ((Item_func_opt_neg *) item_func)->negated)
    return 0;
  for (uint32_t i=0; i < arg_count ; i++)
    if (!args[i]->eq(item_func->arguments()[i], binary_cmp))
      return 0;
  return 1;
}


void Item_func_interval::fix_length_and_dec()
{
  uint32_t rows= row->cols();

  use_decimal_comparison= ((row->element_index(0)->result_type() ==
                            DECIMAL_RESULT) ||
                           (row->element_index(0)->result_type() ==
                            INT_RESULT));
  if (rows > 8)
  {
    bool not_null_consts= true;

    for (uint32_t i= 1; not_null_consts && i < rows; i++)
    {
      Item *el= row->element_index(i);
      not_null_consts&= el->const_item() & !el->is_null();
    }

    if (not_null_consts &&
        (intervals=
          (interval_range*) memory::sql_alloc(sizeof(interval_range) * (rows - 1))))
    {
      if (use_decimal_comparison)
      {
        for (uint32_t i= 1; i < rows; i++)
        {
          Item *el= row->element_index(i);
          interval_range *range= intervals + (i-1);
          if ((el->result_type() == DECIMAL_RESULT) ||
              (el->result_type() == INT_RESULT))
          {
            range->type= DECIMAL_RESULT;
            range->dec.init();
            type::Decimal *dec= el->val_decimal(&range->dec);
            if (dec != &range->dec)
            {
              range->dec= *dec;
              range->dec.fix_buffer_pointer();
            }
          }
          else
          {
            range->type= REAL_RESULT;
            range->dbl= el->val_real();
          }
        }
      }
      else
      {
        for (uint32_t i= 1; i < rows; i++)
        {
          intervals[i-1].dbl= row->element_index(i)->val_real();
        }
      }
    }
  }
  maybe_null= 0;
  max_length= 2;
  used_tables_cache|= row->used_tables();
  not_null_tables_cache= row->not_null_tables();
  with_sum_func= with_sum_func || row->with_sum_func;
  const_item_cache&= row->const_item();
}
# 1891 "drizzled/item/cmpfunc.cc"
int64_t Item_func_interval::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 1893, __PRETTY_FUNCTION__));
  double value;
  type::Decimal dec_buf, *dec= __null;
  uint32_t i;

  if (use_decimal_comparison)
  {
    dec= row->element_index(0)->val_decimal(&dec_buf);
    if (row->element_index(0)->null_value)
      return -1;
    class_decimal2double(30, dec, &value);
  }
  else
  {
    value= row->element_index(0)->val_real();
    if (row->element_index(0)->null_value)
      return -1;
  }

  if (intervals)
  {
    uint32_t start,end;
    start= 0;
    end= row->cols()-2;
    while (start != end)
    {
      uint32_t mid= (start + end + 1) / 2;
      interval_range *range= intervals + mid;
      bool cmp_result;





      if (dec && range->type == DECIMAL_RESULT)
        cmp_result= class_decimal_cmp(&range->dec, dec) <= 0;
      else
        cmp_result= (range->dbl <= value);
      if (cmp_result)
 start= mid;
      else
 end= mid - 1;
    }
    interval_range *range= intervals+start;
    return ((dec && range->type == DECIMAL_RESULT) ?
            class_decimal_cmp(dec, &range->dec) < 0 :
            value < range->dbl) ? 0 : start + 1;
  }

  for (i=1 ; i < row->cols() ; i++)
  {
    Item *el= row->element_index(i);
    if (use_decimal_comparison &&
        ((el->result_type() == DECIMAL_RESULT) ||
         (el->result_type() == INT_RESULT)))
    {
      type::Decimal e_dec_buf, *e_dec= el->val_decimal(&e_dec_buf);

      if (el->null_value)
        continue;
      if (class_decimal_cmp(e_dec, dec) > 0)
        return i - 1;
    }
    else
    {
      double val= el->val_real();

      if (el->null_value)
        continue;
      if (val > value)
        return i - 1;
    }
  }
  return i-1;
}
# 1998 "drizzled/item/cmpfunc.cc"
bool Item_func_between::fix_fields(Session *session, Item **ref)
{
  if (Item_func_opt_neg::fix_fields(session, ref))
    return 1;

  session->lex().current_select->between_count++;


  if (pred_level && !negated)
    return 0;


  not_null_tables_cache= (args[0]->not_null_tables() |
                          (args[1]->not_null_tables() &
                           args[2]->not_null_tables()));

  return 0;
}


void Item_func_between::fix_length_and_dec()
{
  max_length= 1;
  int i;
  bool datetime_found= false;
  compare_as_dates= true;





  if (!args[0] || !args[1] || !args[2])
    return;
  if ( agg_cmp_type(&cmp_type, args, 3))
    return;
  if (cmp_type == STRING_RESULT &&
      agg_arg_charsets(cmp_collation, args, 3, 7, 1))
   return;






  if (cmp_type == STRING_RESULT)
  {
    for (i= 0; i < 3; i++)
    {
      if (args[i]->is_datetime())
      {
        datetime_found= true;
        continue;
      }
    }
  }
  if (!datetime_found)
    compare_as_dates= false;

  if (compare_as_dates)
  {
    ge_cmp.set_datetime_cmp_func(args, args + 1);
    le_cmp.set_datetime_cmp_func(args, args + 2);
  }
  else if (args[0]->real_item()->type() == FIELD_ITEM)
  {
    Item_field *field_item= (Item_field*) (args[0]->real_item());
    if (field_item->field->can_be_compared_as_int64_t())
    {




      if (convert_constant_item(&getSession(), field_item, &args[1]))
        cmp_type=INT_RESULT;
      if (convert_constant_item(&getSession(), field_item, &args[2]))
        cmp_type=INT_RESULT;
    }
  }
}


int64_t Item_func_between::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2081, __PRETTY_FUNCTION__));
  if (compare_as_dates)
  {
    int ge_res, le_res;

    ge_res= ge_cmp.compare();
    if ((null_value= args[0]->null_value))
      return 0;
    le_res= le_cmp.compare();

    if (!args[1]->null_value && !args[2]->null_value)
      return (int64_t) ((ge_res >= 0 && le_res <=0) != negated);
    else if (args[1]->null_value)
    {
      null_value= le_res > 0;
    }
    else
    {
      null_value= ge_res < 0;
    }
  }
  else if (cmp_type == STRING_RESULT)
  {
    String *value,*a,*b;
    value=args[0]->val_str(&value0);
    if ((null_value=args[0]->null_value))
      return 0;
    a=args[1]->val_str(&value1);
    b=args[2]->val_str(&value2);
    if (!args[1]->null_value && !args[2]->null_value)
      return (int64_t) ((sortcmp(value,a,cmp_collation.collation) >= 0 &&
                          sortcmp(value,b,cmp_collation.collation) <= 0) !=
                         negated);
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
    {

      null_value= sortcmp(value,b,cmp_collation.collation) <= 0;
    }
    else
    {

      null_value= sortcmp(value,a,cmp_collation.collation) >= 0;
    }
  }
  else if (cmp_type == INT_RESULT)
  {
    int64_t value=args[0]->val_int(), a, b;
    if ((null_value=args[0]->null_value))
      return 0;
    a=args[1]->val_int();
    b=args[2]->val_int();
    if (!args[1]->null_value && !args[2]->null_value)
      return (int64_t) ((value >= a && value <= b) != negated);
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
    {
      null_value= value <= b;
    }
    else
    {
      null_value= value >= a;
    }
  }
  else if (cmp_type == DECIMAL_RESULT)
  {
    type::Decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf),
               a_buf, *a_dec, b_buf, *b_dec;
    if ((null_value=args[0]->null_value))
      return 0;
    a_dec= args[1]->val_decimal(&a_buf);
    b_dec= args[2]->val_decimal(&b_buf);
    if (!args[1]->null_value && !args[2]->null_value)
      return (int64_t) ((class_decimal_cmp(dec, a_dec) >= 0 &&
                          class_decimal_cmp(dec, b_dec) <= 0) != negated);
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
      null_value= (class_decimal_cmp(dec, b_dec) <= 0);
    else
      null_value= (class_decimal_cmp(dec, a_dec) >= 0);
  }
  else
  {
    double value= args[0]->val_real(),a,b;
    if ((null_value=args[0]->null_value))
      return 0;
    a= args[1]->val_real();
    b= args[2]->val_real();
    if (!args[1]->null_value && !args[2]->null_value)
      return (int64_t) ((value >= a && value <= b) != negated);
    if (args[1]->null_value && args[2]->null_value)
      null_value=1;
    else if (args[1]->null_value)
    {
      null_value= value <= b;
    }
    else
    {
      null_value= value >= a;
    }
  }
  return (int64_t) (!null_value && negated);
}


void Item_func_between::print(String *str)
{
  str->append('(');
  args[0]->print(str);
  if (negated)
    str->append((" not"), (sizeof(" not") - 1));
  str->append((" between "), (sizeof(" between ") - 1));
  args[1]->print(str);
  str->append((" and "), (sizeof(" and ") - 1));
  args[2]->print(str);
  str->append(')');
}

void
Item_func_ifnull::fix_length_and_dec()
{
  agg_result_type(&hybrid_type, args, 2);
  maybe_null= args[1]->maybe_null;
  decimals= max(args[0]->decimals, args[1]->decimals);
  unsigned_flag= args[0]->unsigned_flag && args[1]->unsigned_flag;

  if (hybrid_type == DECIMAL_RESULT || hybrid_type == INT_RESULT)
  {
    int len0= args[0]->max_length - args[0]->decimals
      - (args[0]->unsigned_flag ? 0 : 1);

    int len1= args[1]->max_length - args[1]->decimals
      - (args[1]->unsigned_flag ? 0 : 1);

    max_length= max(len0, len1) + decimals + (unsigned_flag ? 0 : 1);
  }
  else
  {
    max_length= max(args[0]->max_length, args[1]->max_length);
  }

  switch (hybrid_type)
  {
  case STRING_RESULT:
    agg_arg_charsets(collation, args, arg_count, 7, 1);
    break;

  case DECIMAL_RESULT:
  case REAL_RESULT:
    break;

  case INT_RESULT:
    decimals= 0;
    break;

  case ROW_RESULT:
    ((0) ? static_cast<void> (0) : __assert_fail ("0", "drizzled/item/cmpfunc.cc", 2240, __PRETTY_FUNCTION__));
  }

  cached_field_type= agg_field_type(args, 2);
}


uint32_t Item_func_ifnull::decimal_precision() const
{
  int max_int_part= max(args[0]->decimal_int_part(),args[1]->decimal_int_part());
  return min(max_int_part + decimals, ((9 * 9) - 8*2));
}


enum_field_types Item_func_ifnull::field_type() const
{
  return cached_field_type;
}

Field *Item_func_ifnull::tmp_table_field(Table *table)
{
  return tmp_table_field_from_field_type(table, 0);
}

double
Item_func_ifnull::real_op()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2267, __PRETTY_FUNCTION__));
  double value= args[0]->val_real();
  if (!args[0]->null_value)
  {
    null_value=0;
    return value;
  }
  value= args[1]->val_real();
  if ((null_value=args[1]->null_value))
    return 0.0;
  return value;
}

int64_t
Item_func_ifnull::int_op()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2283, __PRETTY_FUNCTION__));
  int64_t value=args[0]->val_int();
  if (!args[0]->null_value)
  {
    null_value=0;
    return value;
  }
  value=args[1]->val_int();
  if ((null_value=args[1]->null_value))
    return 0;
  return value;
}


type::Decimal *Item_func_ifnull::decimal_op(type::Decimal *decimal_value)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2299, __PRETTY_FUNCTION__));
  type::Decimal *value= args[0]->val_decimal(decimal_value);
  if (!args[0]->null_value)
  {
    null_value= 0;
    return value;
  }
  value= args[1]->val_decimal(decimal_value);
  if ((null_value= args[1]->null_value))
    return 0;
  return value;
}


String *
Item_func_ifnull::str_op(String *str)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2316, __PRETTY_FUNCTION__));
  String *res =args[0]->val_str(str);
  if (!args[0]->null_value)
  {
    null_value=0;
    res->set_charset(collation.collation);
    return res;
  }
  res=args[1]->val_str(str);
  if ((null_value=args[1]->null_value))
    return 0;
  res->set_charset(collation.collation);
  return res;
}
# 2358 "drizzled/item/cmpfunc.cc"
bool
Item_func_if::fix_fields(Session *session, Item **ref)
{
  ((fixed == 0) ? static_cast<void> (0) : __assert_fail ("fixed == 0", "drizzled/item/cmpfunc.cc", 2361, __PRETTY_FUNCTION__));
  args[0]->top_level_item();

  if (Item_func::fix_fields(session, ref))
    return 1;

  not_null_tables_cache= (args[1]->not_null_tables() &
                          args[2]->not_null_tables());

  return 0;
}


void Item_func_if::fix_length_and_dec()
{
  maybe_null= args[1]->maybe_null || args[2]->maybe_null;
  decimals= max(args[1]->decimals, args[2]->decimals);
  unsigned_flag= args[1]->unsigned_flag && args[2]->unsigned_flag;

  enum Item_result arg1_type= args[1]->result_type();
  enum Item_result arg2_type= args[2]->result_type();
  bool null1= args[1]->const_item() && args[1]->null_value;
  bool null2= args[2]->const_item() && args[2]->null_value;

  if (null1)
  {
    cached_result_type= arg2_type;
    collation.set(args[2]->collation.collation);
    cached_field_type= args[2]->field_type();
  }
  else if (null2)
  {
    cached_result_type= arg1_type;
    collation.set(args[1]->collation.collation);
    cached_field_type= args[1]->field_type();
  }
  else
  {
    agg_result_type(&cached_result_type, args +1, 2);
    if (cached_result_type == STRING_RESULT)
    {
      if (agg_arg_charsets(collation, args +1, 2, 3, 1))
        return;
    }
    else
    {
      collation.set(&my_charset_bin);
    }
    cached_field_type= agg_field_type(args +1, 2);
  }

  switch (cached_result_type)
  {
  case DECIMAL_RESULT:
  case INT_RESULT:
    {
      int len1= args[1]->max_length -args[1]->decimals -(args[1]->unsigned_flag ? 0 : 1);
      int len2= args[2]->max_length -args[2]->decimals -(args[2]->unsigned_flag ? 0 : 1);
      max_length= max(len1, len2) + decimals + (unsigned_flag ? 0 : 1);
    }
    break;
  case REAL_RESULT:
  case STRING_RESULT:
    max_length= max(args[1]->max_length, args[2]->max_length);
    break;

  case ROW_RESULT:
    ((0) ? static_cast<void> (0) : __assert_fail ("0", "drizzled/item/cmpfunc.cc", 2428, __PRETTY_FUNCTION__));
    break;
  }
}


uint32_t Item_func_if::decimal_precision() const
{
  int precision= (max(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
                  decimals);
  return min(precision, ((9 * 9) - 8*2));
}


double
Item_func_if::val_real()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2445, __PRETTY_FUNCTION__));
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
  double value= arg->val_real();
  null_value=arg->null_value;
  return value;
}

int64_t
Item_func_if::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2455, __PRETTY_FUNCTION__));
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
  int64_t value= arg->val_int();
  null_value= arg->null_value;
  return value;
}

String *
Item_func_if::val_str(String *str)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2465, __PRETTY_FUNCTION__));
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
  String *res= arg->val_str(str);
  if (res)
  {
    res->set_charset(collation.collation);
  }
  null_value= arg->null_value;
  return res;
}


type::Decimal *
Item_func_if::val_decimal(type::Decimal *decimal_value)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2480, __PRETTY_FUNCTION__));
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
  type::Decimal *value= arg->val_decimal(decimal_value);
  null_value= arg->null_value;
  return value;
}


void
Item_func_nullif::fix_length_and_dec()
{
  Item_bool_func2::fix_length_and_dec();
  maybe_null=1;
  if (args[0])
  {
    max_length=args[0]->max_length;
    decimals=args[0]->decimals;
    unsigned_flag= args[0]->unsigned_flag;
    cached_result_type= args[0]->result_type();
    if (cached_result_type == STRING_RESULT &&
        agg_arg_charsets(collation, args, arg_count, 7, 1))
      return;
  }
}
# 2516 "drizzled/item/cmpfunc.cc"
double
Item_func_nullif::val_real()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2519, __PRETTY_FUNCTION__));
  double value;
  if (!cmp.compare())
  {
    null_value=1;
    return 0.0;
  }
  value= args[0]->val_real();
  null_value=args[0]->null_value;
  return value;
}

int64_t
Item_func_nullif::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2534, __PRETTY_FUNCTION__));
  int64_t value;
  if (!cmp.compare())
  {
    null_value=1;
    return 0;
  }
  value=args[0]->val_int();
  null_value=args[0]->null_value;
  return value;
}

String *
Item_func_nullif::val_str(String *str)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2549, __PRETTY_FUNCTION__));
  String *res;
  if (!cmp.compare())
  {
    null_value=1;
    return 0;
  }
  res=args[0]->val_str(str);
  null_value=args[0]->null_value;
  return res;
}


type::Decimal *
Item_func_nullif::val_decimal(type::Decimal * decimal_value)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2565, __PRETTY_FUNCTION__));
  type::Decimal *res;
  if (!cmp.compare())
  {
    null_value=1;
    return 0;
  }
  res= args[0]->val_decimal(decimal_value);
  null_value= args[0]->null_value;
  return res;
}


bool
Item_func_nullif::is_null()
{
  return (null_value= (!cmp.compare() ? 1 : args[0]->null_value));
}
# 2606 "drizzled/item/cmpfunc.cc"
Item *Item_func_case::find_item(String *)
{
  uint32_t value_added_map= 0;

  if (first_expr_num == -1)
  {
    for (uint32_t i=0 ; i < ncases ; i+=2)
    {

      if (args[i]->val_bool())
 return args[i+1];
      continue;
    }
  }
  else
  {

    for (uint32_t i=0 ; i < ncases ; i+=2)
    {
      cmp_type= item_cmp_type(left_result_type, args[i]->result_type());
      ((cmp_type != ROW_RESULT) ? static_cast<void> (0) : __assert_fail ("cmp_type != ROW_RESULT", "drizzled/item/cmpfunc.cc", 2626, __PRETTY_FUNCTION__));
      ((cmp_items[(uint32_t)cmp_type]) ? static_cast<void> (0) : __assert_fail ("cmp_items[(uint32_t)cmp_type]", "drizzled/item/cmpfunc.cc", 2627, __PRETTY_FUNCTION__));
      if (!(value_added_map & (1<<(uint32_t)cmp_type)))
      {
        cmp_items[(uint32_t)cmp_type]->store_value(args[first_expr_num]);
        if ((null_value=args[first_expr_num]->null_value))
          return else_expr_num != -1 ? args[else_expr_num] : 0;
        value_added_map|= 1<<(uint32_t)cmp_type;
      }
      if (!cmp_items[(uint32_t)cmp_type]->cmp(args[i]) && !args[i]->null_value)
        return args[i + 1];
    }
  }

  return else_expr_num != -1 ? args[else_expr_num] : 0;
}


String *Item_func_case::val_str(String *str)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2646, __PRETTY_FUNCTION__));
  String *res;
  Item *item=find_item(str);

  if (!item)
  {
    null_value=1;
    return 0;
  }
  null_value= 0;
  if (!(res=item->val_str(str)))
    null_value= 1;
  return res;
}


int64_t Item_func_case::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2664, __PRETTY_FUNCTION__));
  char buff[(255*4 +1)];
  String dummy_str(buff,sizeof(buff),default_charset());
  Item *item=find_item(&dummy_str);
  int64_t res;

  if (!item)
  {
    null_value=1;
    return 0;
  }
  res=item->val_int();
  null_value=item->null_value;
  return res;
}

double Item_func_case::val_real()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2682, __PRETTY_FUNCTION__));
  char buff[(255*4 +1)];
  String dummy_str(buff,sizeof(buff),default_charset());
  Item *item=find_item(&dummy_str);
  double res;

  if (!item)
  {
    null_value=1;
    return 0;
  }
  res= item->val_real();
  null_value=item->null_value;
  return res;
}


type::Decimal *Item_func_case::val_decimal(type::Decimal *decimal_value)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2701, __PRETTY_FUNCTION__));
  char buff[(255*4 +1)];
  String dummy_str(buff, sizeof(buff), default_charset());
  Item *item= find_item(&dummy_str);
  type::Decimal *res;

  if (!item)
  {
    null_value=1;
    return 0;
  }

  res= item->val_decimal(decimal_value);
  null_value= item->null_value;
  return res;
}


bool Item_func_case::fix_fields(Session *session, Item **ref)
{




  unsigned char buff[(255*4 +1)*2+sizeof(String)*2+sizeof(String*)*2
                     +sizeof(double)*2+sizeof(int64_t)*2];
  bool res= Item_func::fix_fields(session, ref);




  if (check_stack_overrun(session, 12000, buff))
    return true;
  return res;
}


void Item_func_case::agg_str_lengths(Item* arg)
{
  set_if_bigger(max_length, arg->max_length);
  set_if_bigger(decimals, arg->decimals);
  unsigned_flag= unsigned_flag && arg->unsigned_flag;
}


void Item_func_case::agg_num_lengths(Item *arg)
{
  uint32_t len= class_decimal_length_to_precision(arg->max_length, arg->decimals,
                                           arg->unsigned_flag) - arg->decimals;
  set_if_bigger(max_length, len);
  set_if_bigger(decimals, arg->decimals);
  unsigned_flag= unsigned_flag && arg->unsigned_flag;
}


void Item_func_case::fix_length_and_dec()
{
  Item **agg;
  uint32_t nagg;
  uint32_t found_types= 0;
  if (!(agg= (Item**) memory::sql_alloc(sizeof(Item*)*(ncases+1))))
    return;






  for (nagg= 0 ; nagg < ncases/2 ; nagg++)
    agg[nagg]= args[nagg*2+1];

  if (else_expr_num != -1)
    agg[nagg++]= args[else_expr_num];

  agg_result_type(&cached_result_type, agg, nagg);
  if ((cached_result_type == STRING_RESULT) &&
      agg_arg_charsets(collation, agg, nagg, 3, 1))
    return;

  cached_field_type= agg_field_type(agg, nagg);




  if (first_expr_num != -1)
  {
    agg[0]= args[first_expr_num];
    left_result_type= agg[0]->result_type();

    for (nagg= 0; nagg < ncases/2 ; nagg++)
      agg[nagg+1]= args[nagg*2];
    nagg++;
    if (!(found_types= collect_cmp_types(agg, nagg)))
      return;

    for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
    {
      if (found_types & (1 << i) && !cmp_items[i])
      {
        (((Item_result)i != ROW_RESULT) ? static_cast<void> (0) : __assert_fail ("(Item_result)i != ROW_RESULT", "drizzled/item/cmpfunc.cc", 2800, __PRETTY_FUNCTION__));
        if ((Item_result)i == STRING_RESULT &&
            agg_arg_charsets(cmp_collation, agg, nagg, 7, 1))
          return;
        if (!(cmp_items[i]=
            cmp_item::get_comparator((Item_result)i,
                                     cmp_collation.collation)))
          return;
      }
    }
  }

  if (else_expr_num == -1 || args[else_expr_num]->maybe_null)
    maybe_null=1;

  max_length=0;
  decimals=0;
  unsigned_flag= true;
  if (cached_result_type == STRING_RESULT)
  {
    for (uint32_t i= 0; i < ncases; i+= 2)
      agg_str_lengths(args[i + 1]);
    if (else_expr_num != -1)
      agg_str_lengths(args[else_expr_num]);
  }
  else
  {
    for (uint32_t i= 0; i < ncases; i+= 2)
      agg_num_lengths(args[i + 1]);
    if (else_expr_num != -1)
      agg_num_lengths(args[else_expr_num]);
    max_length= class_decimal_precision_to_length(max_length + decimals, decimals,
                                               unsigned_flag);
  }
}


uint32_t Item_func_case::decimal_precision() const
{
  int max_int_part=0;
  for (uint32_t i=0 ; i < ncases ; i+=2)
    set_if_bigger(max_int_part, args[i+1]->decimal_int_part());

  if (else_expr_num != -1)
    set_if_bigger(max_int_part, args[else_expr_num]->decimal_int_part());
  return min(max_int_part + decimals, ((9 * 9) - 8*2));
}







void Item_func_case::print(String *str)
{
  str->append(("(case "), (sizeof("(case ") - 1));
  if (first_expr_num != -1)
  {
    args[first_expr_num]->print(str);
    str->append(' ');
  }
  for (uint32_t i=0 ; i < ncases ; i+=2)
  {
    str->append(("when "), (sizeof("when ") - 1));
    args[i]->print(str);
    str->append((" then "), (sizeof(" then ") - 1));
    args[i+1]->print(str);
    str->append(' ');
  }
  if (else_expr_num != -1)
  {
    str->append(("else "), (sizeof("else ") - 1));
    args[else_expr_num]->print(str);
    str->append(' ');
  }
  str->append(("end)"), (sizeof("end)") - 1));
}


void Item_func_case::cleanup()
{
  Item_func::cleanup();
  for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
  {
    delete cmp_items[i];
    cmp_items[i]= 0;
  }
}






String *Item_func_coalesce::str_op(String *str)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2897, __PRETTY_FUNCTION__));
  null_value=0;
  for (uint32_t i=0 ; i < arg_count ; i++)
  {
    String *res;
    if ((res=args[i]->val_str(str)))
      return res;
  }
  null_value=1;
  return 0;
}

int64_t Item_func_coalesce::int_op()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2911, __PRETTY_FUNCTION__));
  null_value=0;
  for (uint32_t i=0 ; i < arg_count ; i++)
  {
    int64_t res=args[i]->val_int();
    if (!args[i]->null_value)
      return res;
  }
  null_value=1;
  return 0;
}

double Item_func_coalesce::real_op()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2925, __PRETTY_FUNCTION__));
  null_value=0;
  for (uint32_t i=0 ; i < arg_count ; i++)
  {
    double res= args[i]->val_real();
    if (!args[i]->null_value)
      return res;
  }
  null_value=1;
  return 0;
}


type::Decimal *Item_func_coalesce::decimal_op(type::Decimal *decimal_value)
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 2940, __PRETTY_FUNCTION__));
  null_value= 0;
  for (uint32_t i= 0; i < arg_count; i++)
  {
    type::Decimal *res= args[i]->val_decimal(decimal_value);
    if (!args[i]->null_value)
      return res;
  }
  null_value=1;
  return 0;
}


void Item_func_coalesce::fix_length_and_dec()
{
  cached_field_type= agg_field_type(args, arg_count);
  agg_result_type(&hybrid_type, args, arg_count);

  switch (hybrid_type) {
  case STRING_RESULT:
    count_only_length();
    decimals= (uint8_t)31;
    agg_arg_charsets(collation, args, arg_count, 3, 1);
    break;

  case DECIMAL_RESULT:
    count_decimal_length();
    break;

  case REAL_RESULT:
    count_real_length();
    break;

  case INT_RESULT:
    count_only_length();
    decimals= 0;
    break;

  case ROW_RESULT:
    ((0) ? static_cast<void> (0) : __assert_fail ("0", "drizzled/item/cmpfunc.cc", 2979, __PRETTY_FUNCTION__));
  }
}
# 3005 "drizzled/item/cmpfunc.cc"
static inline int cmp_longs (int64_t a_val, int64_t b_val)
{
  return a_val < b_val ? -1 : a_val == b_val ? 0 : 1;
}
# 3029 "drizzled/item/cmpfunc.cc"
static inline int cmp_ulongs (uint64_t a_val, uint64_t b_val)
{
  return a_val < b_val ? -1 : a_val == b_val ? 0 : 1;
}
# 3058 "drizzled/item/cmpfunc.cc"
int cmp_int64_t(void *, in_int64_t::packed_int64_t *a,
                in_int64_t::packed_int64_t *b)
{
  if (a->unsigned_flag != b->unsigned_flag)
  {




    if ((a->unsigned_flag && ((uint64_t) a->val) > (uint64_t) (9223372036854775807LL)) ||
        (b->unsigned_flag && ((uint64_t) b->val) > (uint64_t) (9223372036854775807LL)))
      return a->unsigned_flag ? 1 : -1;




    return cmp_longs (a->val, b->val);
  }
  if (a->unsigned_flag)
    return cmp_ulongs ((uint64_t) a->val, (uint64_t) b->val);
  else
    return cmp_longs (a->val, b->val);
}

static int cmp_double(void *, double *a, double *b)
{
  return *a < *b ? -1 : *a == *b ? 0 : 1;
}

static int cmp_row(void *, cmp_item_row *a, cmp_item_row *b)
{
  return a->compare(b);
}


static int cmp_decimal(void *, type::Decimal *a, type::Decimal *b)
{




  a->fix_buffer_pointer();
  b->fix_buffer_pointer();
  return class_decimal_cmp(a, b);
}


void in_vector::sort()
{
  internal::my_qsort2(base,used_count,size,compare, (void *) collation);
}


int in_vector::find(Item *item)
{
  unsigned char *result=get_value(item);
  if (!result || !used_count)
    return 0;

  uint32_t start,end;
  start=0; end=used_count-1;
  while (start != end)
  {
    uint32_t mid=(start+end+1)/2;
    int res;
    if ((res=(*compare)(collation, base+mid*size, result)) == 0)
      return 1;
    if (res < 0)
      start=mid;
    else
      end=mid-1;
  }
  return (int) ((*compare)(collation, base+start*size, result) == 0);
}

in_string::in_string(uint32_t elements,qsort2_cmp cmp_func, const charset_info_st * const cs)
  :in_vector(elements, sizeof(String), cmp_func, cs),
   tmp(buff, sizeof(buff), &my_charset_bin)
{}

in_string::~in_string()
{
  if (base)
  {

    for (uint32_t i=0 ; i < count ; i++)
      ((String*) base)[i].free();
  }
}

void in_string::set(uint32_t pos,Item *item)
{
  String *str=((String*) base)+pos;
  String *res=item->val_str(str);
  if (res && res != str)
  {
    if (res->uses_buffer_owned_by(str))
      res->copy();
    if (item->type() == Item::FUNC_ITEM)
      str->copy(*res);
    else
      *str= *res;
  }
  if (!str->charset())
  {
    const charset_info_st *cs;
    if (!(cs= item->collation.collation))
      cs= &my_charset_bin;
    str->set_charset(cs);
  }
}


unsigned char *in_string::get_value(Item *item)
{
  return (unsigned char*) item->val_str(&tmp);
}

in_row::in_row(uint32_t elements, Item *)
{
  base= (char*) new cmp_item_row[count= elements];
  size= sizeof(cmp_item_row);
  compare= (qsort2_cmp) cmp_row;




  used_count= elements;
  collation= 0;
}

in_row::~in_row()
{
  delete[] (cmp_item_row*) base;
}

unsigned char *in_row::get_value(Item *item)
{
  tmp.store_value(item);
  if (item->is_null())
    return 0;
  return (unsigned char *)&tmp;
}

void in_row::set(uint32_t pos, Item *item)
{
  ((cmp_item_row*) base)[pos].store_value_by_template(&tmp, item);
  return;
}

in_int64_t::in_int64_t(uint32_t elements) :
  in_vector(elements, sizeof(packed_int64_t),(qsort2_cmp) cmp_int64_t, 0)
{}

void in_int64_t::set(uint32_t pos,Item *item)
{
  struct packed_int64_t *buff= &((packed_int64_t*) base)[pos];

  buff->val= item->val_int();
  buff->unsigned_flag= item->unsigned_flag;
}

unsigned char *in_int64_t::get_value(Item *item)
{
  tmp.val= item->val_int();
  if (item->null_value)
    return 0;
  tmp.unsigned_flag= item->unsigned_flag;
  return (unsigned char*) &tmp;
}

in_datetime::in_datetime(Item *warn_item_arg, uint32_t elements) :
  in_int64_t(elements),
  session(::drizzled::_current_session()),
  warn_item(warn_item_arg),
  lval_cache(0)
{}

void in_datetime::set(uint32_t pos, Item *item)
{
  Item **tmp_item= &item;
  bool is_null;
  struct packed_int64_t *buff= &((packed_int64_t*) base)[pos];

  buff->val= get_datetime_value(session, &tmp_item, 0, warn_item, &is_null);
  buff->unsigned_flag= 1L;
}

unsigned char *in_datetime::get_value(Item *item)
{
  bool is_null;
  Item **tmp_item= lval_cache ? &lval_cache : &item;
  tmp.val= get_datetime_value(session, &tmp_item, &lval_cache, warn_item, &is_null);
  if (item->null_value)
    return 0;
  tmp.unsigned_flag= 1L;
  return (unsigned char*) &tmp;
}

in_double::in_double(uint32_t elements)
  :in_vector(elements,sizeof(double),(qsort2_cmp) cmp_double, 0)
{}

void in_double::set(uint32_t pos,Item *item)
{
  ((double*) base)[pos]= item->val_real();
}

unsigned char *in_double::get_value(Item *item)
{
  tmp= item->val_real();
  if (item->null_value)
    return 0;
  return (unsigned char*) &tmp;
}


in_decimal::in_decimal(uint32_t elements)
  :in_vector(elements, sizeof(type::Decimal),(qsort2_cmp) cmp_decimal, 0)
{}


void in_decimal::set(uint32_t pos, Item *item)
{

  type::Decimal *dec= ((type::Decimal *)base) + pos;
  dec->len= 9;
  dec->fix_buffer_pointer();
  type::Decimal *res= item->val_decimal(dec);

  if (!item->null_value && res != dec)
    class_decimal2decimal(res, dec);
}


unsigned char *in_decimal::get_value(Item *item)
{
  type::Decimal *result= item->val_decimal(&val);
  if (item->null_value)
    return 0;
  return (unsigned char *)result;
}


cmp_item* cmp_item::get_comparator(Item_result type,
                                   const charset_info_st * const cs)
{
  switch (type) {
  case STRING_RESULT:
    return new cmp_item_sort_string(cs);

  case INT_RESULT:
    return new cmp_item_int;

  case REAL_RESULT:
    return new cmp_item_real;

  case ROW_RESULT:
    return new cmp_item_row;

  case DECIMAL_RESULT:
    return new cmp_item_decimal;
  }

  return 0;
}


cmp_item* cmp_item_sort_string::make_same()
{
  return new cmp_item_sort_string_in_static(cmp_charset);
}

cmp_item* cmp_item_int::make_same()
{
  return new cmp_item_int();
}

cmp_item* cmp_item_real::make_same()
{
  return new cmp_item_real();
}

cmp_item* cmp_item_row::make_same()
{
  return new cmp_item_row();
}


cmp_item_row::~cmp_item_row()
{
  if (comparators)
  {
    for (uint32_t i= 0; i < n; i++)
    {
      if (comparators[i])
 delete comparators[i];
    }
  }
  return;
}


void cmp_item_row::alloc_comparators()
{
  if (!comparators)
    comparators= (cmp_item **) ::drizzled::_current_session()->mem.calloc(sizeof(cmp_item *)*n);
}


void cmp_item_row::store_value(Item *item)
{
  n= item->cols();
  alloc_comparators();
  if (comparators)
  {
    item->bring_value();
    item->null_value= 0;
    for (uint32_t i=0; i < n; i++)
    {
      if (!comparators[i])
        if (!(comparators[i]=
              cmp_item::get_comparator(item->element_index(i)->result_type(),
                                       item->element_index(i)->collation.collation)))
   break;
      comparators[i]->store_value(item->element_index(i));
      item->null_value|= item->element_index(i)->null_value;
    }
  }
  return;
}


void cmp_item_row::store_value_by_template(cmp_item *t, Item *item)
{
  cmp_item_row *tmpl= (cmp_item_row*) t;
  if (tmpl->n != item->cols())
  {
    my_error(ER_OPERAND_COLUMNS, (static_cast<drizzled::myf>(0)), tmpl->n);
    return;
  }
  n= tmpl->n;
  if ((comparators= (cmp_item **) memory::sql_alloc(sizeof(cmp_item *)*n)))
  {
    item->bring_value();
    item->null_value= 0;
    for (uint32_t i=0; i < n; i++)
    {
      if (!(comparators[i]= tmpl->comparators[i]->make_same()))
 break;
      comparators[i]->store_value_by_template(tmpl->comparators[i],
           item->element_index(i));
      item->null_value|= item->element_index(i)->null_value;
    }
  }
}


int cmp_item_row::cmp(Item *arg)
{
  arg->null_value= 0;
  if (arg->cols() != n)
  {
    my_error(ER_OPERAND_COLUMNS, (static_cast<drizzled::myf>(0)), n);
    return 1;
  }
  bool was_null= 0;
  arg->bring_value();
  for (uint32_t i=0; i < n; i++)
  {
    if (comparators[i]->cmp(arg->element_index(i)))
    {
      if (!arg->element_index(i)->null_value)
 return 1;
      was_null= 1;
    }
  }
  return (arg->null_value= was_null);
}


int cmp_item_row::compare(cmp_item *c)
{
  cmp_item_row *l_cmp= (cmp_item_row *) c;
  for (uint32_t i=0; i < n; i++)
  {
    int res;
    if ((res= comparators[i]->compare(l_cmp->comparators[i])))
      return res;
  }
  return 0;
}


void cmp_item_decimal::store_value(Item *item)
{
  type::Decimal *val= item->val_decimal(&value);

  if (val && val != &value)
    class_decimal2decimal(val, &value);
}


int cmp_item_decimal::cmp(Item *arg)
{
  type::Decimal tmp_buf, *tmp= arg->val_decimal(&tmp_buf);
  if (arg->null_value)
    return 1;
  return class_decimal_cmp(&value, tmp);
}


int cmp_item_decimal::compare(cmp_item *arg)
{
  cmp_item_decimal *l_cmp= (cmp_item_decimal*) arg;
  return class_decimal_cmp(&value, &l_cmp->value);
}


cmp_item* cmp_item_decimal::make_same()
{
  return new cmp_item_decimal();
}


void cmp_item_datetime::store_value(Item *item)
{
  bool is_null;
  Item **tmp_item= lval_cache ? &lval_cache : &item;
  value= get_datetime_value(session, &tmp_item, &lval_cache, warn_item, &is_null);
}


int cmp_item_datetime::cmp(Item *arg)
{
  bool is_null;
  Item **tmp_item= &arg;
  return value !=
    get_datetime_value(session, &tmp_item, 0, warn_item, &is_null);
}


int cmp_item_datetime::compare(cmp_item *ci)
{
  cmp_item_datetime *l_cmp= (cmp_item_datetime *)ci;
  return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
}


cmp_item *cmp_item_datetime::make_same()
{
  return new cmp_item_datetime(warn_item);
}


bool Item_func_in::nulls_in_row()
{
  Item **arg,**arg_end;
  for (arg= args+1, arg_end= args+arg_count; arg != arg_end ; arg++)
  {
    if ((*arg)->null_inside())
      return 1;
  }
  return 0;
}
# 3553 "drizzled/item/cmpfunc.cc"
bool
Item_func_in::fix_fields(Session *session, Item **ref)
{
  Item **arg, **arg_end;

  if (Item_func_opt_neg::fix_fields(session, ref))
    return 1;


  if (pred_level && negated)
    return 0;


  not_null_tables_cache= ~(table_map) 0;
  for (arg= args + 1, arg_end= args + arg_count; arg != arg_end; arg++)
    not_null_tables_cache&= (*arg)->not_null_tables();
  not_null_tables_cache|= (*args)->not_null_tables();
  return 0;
}


static int srtcmp_in(const charset_info_st * const cs, const String *x,const String *y)
{
  return cs->coll->strnncollsp(cs,
                               (unsigned char *) x->ptr(),x->length(),
                               (unsigned char *) y->ptr(),y->length(), 0);
}


void Item_func_in::fix_length_and_dec()
{
  Item **arg, **arg_end;
  bool const_itm= 1;
  bool datetime_found= false;

  bool compare_as_datetime= false;
  Item *date_arg= 0;
  uint32_t found_types= 0;
  uint32_t type_cnt= 0;
  Item_result cmp_type= STRING_RESULT;
  left_result_type= args[0]->result_type();
  if (!(found_types= collect_cmp_types(args, arg_count, true)))
    return;

  for (arg= args + 1, arg_end= args + arg_count; arg != arg_end ; arg++)
  {
    if (!arg[0]->const_item())
    {
      const_itm= 0;
      break;
    }
  }
  for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
  {
    if (found_types & 1 << i)
    {
      (type_cnt)++;
      cmp_type= (Item_result) i;
    }
  }

  if (type_cnt == 1)
  {
    if (cmp_type == STRING_RESULT &&
        agg_arg_charsets(cmp_collation, args, arg_count, 7, 1))
      return;
    arg_types_compatible= true;
  }
  if (type_cnt == 1)
  {




    if (cmp_type == ROW_RESULT)
    {
      cmp_item_row *cmp= 0;
      if (const_itm && !nulls_in_row())
      {
        array= new in_row(arg_count-1, 0);
        cmp= &((in_row*)array)->tmp;
      }
      else
      {
        cmp= new cmp_item_row;
        cmp_items[ROW_RESULT]= cmp;
      }
      cmp->n= args[0]->cols();
      cmp->alloc_comparators();
    }

    if (cmp_type == STRING_RESULT || cmp_type == ROW_RESULT)
    {
      uint32_t col, num_cols= args[0]->cols();

      for (col= 0; col < num_cols; col++)
      {
        bool skip_column= false;




        for (arg= args, arg_end= args + arg_count; arg != arg_end ; arg++)
        {
          Item *itm= ((cmp_type == STRING_RESULT) ? arg[0] :
                      arg[0]->element_index(col));
          if (itm->result_type() != STRING_RESULT)
          {
            skip_column= true;
            break;
          }
          else if (itm->is_datetime())
          {
            datetime_found= true;




            if (!date_arg)
              date_arg= itm;
            else if (itm->field_type() == DRIZZLE_TYPE_DATETIME)
            {
              date_arg= itm;

              if (cmp_type == STRING_RESULT)
                break;
            }
          }
        }
        if (skip_column)
          continue;
        if (datetime_found)
        {
          if (cmp_type == ROW_RESULT)
          {
            cmp_item **cmp= 0;
            if (array)
              cmp= ((in_row*)array)->tmp.comparators + col;
            else
              cmp= ((cmp_item_row*)cmp_items[ROW_RESULT])->comparators + col;
            *cmp= new cmp_item_datetime(date_arg);

            date_arg= 0;
            datetime_found= false;
          }
          else
            compare_as_datetime= true;
        }
      }
    }
  }




  if (type_cnt == 1 && const_itm && !nulls_in_row())
  {
    if (compare_as_datetime)
    {
      array= new in_datetime(date_arg, arg_count - 1);
    }
    else
    {







      if (args[0]->real_item()->type() == FIELD_ITEM &&
          cmp_type != INT_RESULT)
      {
        Item_field *field_item= (Item_field*) (args[0]->real_item());
        if (field_item->field->can_be_compared_as_int64_t())
        {
          bool all_converted= true;
          for (arg=args+1, arg_end=args+arg_count; arg != arg_end ; arg++)
          {
            if (!convert_constant_item (&getSession(), field_item, &arg[0]))
              all_converted= false;
          }
          if (all_converted)
            cmp_type= INT_RESULT;
        }
      }

      switch (cmp_type) {
      case STRING_RESULT:
        array=new in_string(arg_count-1,(qsort2_cmp) srtcmp_in,
                            cmp_collation.collation);
        break;

      case INT_RESULT:
        array= new in_int64_t(arg_count-1);
        break;

      case REAL_RESULT:
        array= new in_double(arg_count-1);
        break;

      case ROW_RESULT:





        ((in_row*)array)->tmp.store_value(args[0]);
        break;

      case DECIMAL_RESULT:
        array= new in_decimal(arg_count - 1);
        break;
      }
    }

    if (array && !(getSession().is_fatal_error))
    {
      uint32_t j=0;
      for (uint32_t arg_num=1 ; arg_num < arg_count ; arg_num++)
      {
        if (!args[arg_num]->null_value)
        {
          array->set(j,args[arg_num]);
          j++;
        }
        else
          have_null= 1;
      }
      if ((array->used_count= j))
        array->sort();
    }
  }
  else
  {
    if (compare_as_datetime)
      cmp_items[STRING_RESULT]= new cmp_item_datetime(date_arg);
    else
    {
      for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
      {
        if (found_types & (1 << i) && !cmp_items[i])
        {
          if ((Item_result)i == STRING_RESULT &&
              agg_arg_charsets(cmp_collation, args, arg_count,
                               7, 1))
            return;
          if (!cmp_items[i] && !(cmp_items[i]=
              cmp_item::get_comparator((Item_result)i,
                                       cmp_collation.collation)))
            return;
        }
      }
    }
  }
  max_length= 1;
}


void Item_func_in::print(String *str)
{
  str->append('(');
  args[0]->print(str);
  if (negated)
    str->append((" not"), (sizeof(" not") - 1));
  str->append((" in ("), (sizeof(" in (") - 1));
  print_args(str, 1);
  str->append(("))"), (sizeof("))") - 1));
}
# 3849 "drizzled/item/cmpfunc.cc"
int64_t Item_func_in::val_int()
{
  cmp_item *in_item;
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 3852, __PRETTY_FUNCTION__));
  uint32_t value_added_map= 0;
  if (array)
  {
    int tmp=array->find(args[0]);
    null_value=args[0]->null_value || (!tmp && have_null);
    return (int64_t) (!null_value && tmp != negated);
  }

  for (uint32_t i= 1 ; i < arg_count ; i++)
  {
    Item_result cmp_type= item_cmp_type(left_result_type, args[i]->result_type());
    in_item= cmp_items[(uint32_t)cmp_type];
    ((in_item) ? static_cast<void> (0) : __assert_fail ("in_item", "drizzled/item/cmpfunc.cc", 3865, __PRETTY_FUNCTION__));
    if (!(value_added_map & (1 << (uint32_t)cmp_type)))
    {
      in_item->store_value(args[0]);
      if ((null_value=args[0]->null_value))
        return 0;
      have_null= 0;
      value_added_map|= 1 << (uint32_t)cmp_type;
    }
    if (!in_item->cmp(args[i]) && !args[i]->null_value)
      return (int64_t) (!negated);
    have_null|= args[i]->null_value;
  }

  null_value= have_null;
  return (int64_t) (!null_value && negated);
}


Item_cond::Item_cond(Session *session, Item_cond *item)
  :item::function::Boolean(session, item),
   abort_on_null(item->abort_on_null),
   and_tables_cache(item->and_tables_cache)
{



}


void Item_cond::copy_andor_arguments(Session *session, Item_cond *item)
{
  List<Item>::iterator li(item->list.begin());
  while (Item *it= li++)
    list.push_back(it->copy_andor_structure(session));
}


bool
Item_cond::fix_fields(Session *session, Item **)
{
  ((fixed == 0) ? static_cast<void> (0) : __assert_fail ("fixed == 0", "drizzled/item/cmpfunc.cc", 3906, __PRETTY_FUNCTION__));
  List<Item>::iterator li(list.begin());
  Item *item;
  void *orig_session_marker= session->session_marker;
  unsigned char buff[sizeof(char*)];
  not_null_tables_cache= used_tables_cache= 0;
  const_item_cache= true;

  if (functype() == COND_OR_FUNC)
    session->session_marker= 0;




  and_tables_cache= ~(table_map) 0;

  if (check_stack_overrun(session, 12000, buff))
    return true;
# 3939 "drizzled/item/cmpfunc.cc"
  while ((item=li++))
  {
    table_map tmp_table_map;
    while (item->type() == Item::COND_ITEM &&
    ((Item_cond*) item)->functype() == functype() &&
           !((Item_cond*) item)->list.is_empty())
    {
      li.replace(((Item_cond*) item)->list);
      ((Item_cond*) item)->list.clear();
      item= &*li;
    }
    if (abort_on_null)
      item->top_level_item();


    if ((!item->fixed &&
  item->fix_fields(session, li.ref())) ||
 (item= &*li)->check_cols(1))
      return true;
    used_tables_cache|= item->used_tables();
    if (item->const_item())
      and_tables_cache= (table_map) 0;
    else
    {
      tmp_table_map= item->not_null_tables();
      not_null_tables_cache|= tmp_table_map;
      and_tables_cache&= tmp_table_map;
      const_item_cache= false;
    }
    with_sum_func= with_sum_func || item->with_sum_func;
    with_subselect|= item->with_subselect;
    if (item->maybe_null)
      maybe_null=1;
  }
  session->lex().current_select->cond_count+= list.size();
  session->session_marker= orig_session_marker;
  fix_length_and_dec();
  fixed= 1;
  return false;
}


void Item_cond::fix_after_pullout(Select_Lex *new_parent, Item **)
{
  List<Item>::iterator li(list.begin());
  Item *item;

  used_tables_cache=0;
  const_item_cache= true;

  and_tables_cache= ~(table_map) 0;
  not_null_tables_cache= 0;

  while ((item=li++))
  {
    table_map tmp_table_map;
    item->fix_after_pullout(new_parent, li.ref());
    item= &*li;
    used_tables_cache|= item->used_tables();
    const_item_cache&= item->const_item();

    if (item->const_item())
      and_tables_cache= (table_map) 0;
    else
    {
      tmp_table_map= item->not_null_tables();
      not_null_tables_cache|= tmp_table_map;
      and_tables_cache&= tmp_table_map;
      const_item_cache= false;
    }
  }
}


bool Item_cond::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
{
  List<Item>::iterator li(list.begin());
  Item *item;
  while ((item= li++))
    if (item->walk(processor, walk_subquery, arg))
      return 1;
  return Item_func::walk(processor, walk_subquery, arg);
}
# 4042 "drizzled/item/cmpfunc.cc"
Item *Item_cond::transform(Item_transformer transformer, unsigned char *arg)
{
  List<Item>::iterator li(list.begin());
  Item *item;
  while ((item= li++))
  {
    Item *new_item= item->transform(transformer, arg);
    if (!new_item)
      return 0;
    *li.ref()= new_item;
  }
  return Item_func::transform(transformer, arg);
}
# 4081 "drizzled/item/cmpfunc.cc"
Item *Item_cond::compile(Item_analyzer analyzer, unsigned char **arg_p,
                         Item_transformer transformer, unsigned char *arg_t)
{
  if (!(this->*analyzer)(arg_p))
    return 0;

  List<Item>::iterator li(list.begin());
  Item *item;
  while ((item= li++))
  {




    unsigned char *arg_v= *arg_p;
    Item *new_item= item->compile(analyzer, &arg_v, transformer, arg_t);
    if (new_item && new_item != item)
      li.replace(new_item);
  }
  return Item_func::transform(transformer, arg_t);
}

void Item_cond::traverse_cond(Cond_traverser traverser,
                              void *arg, traverse_order order)
{
  List<Item>::iterator li(list.begin());
  Item *item;

  switch (order) {
  case (T_PREFIX):
    (*traverser)(this, arg);
    while ((item= li++))
    {
      item->traverse_cond(traverser, arg, order);
    }
    (*traverser)(__null, arg);
    break;
  case (T_POSTFIX):
    while ((item= li++))
    {
      item->traverse_cond(traverser, arg, order);
    }
    (*traverser)(this, arg);
  }
}
# 4144 "drizzled/item/cmpfunc.cc"
void Item_cond::split_sum_func(Session *session, Item **ref_pointer_array, List<Item> &fields)
{
  List<Item>::iterator li(list.begin());
  Item *item;
  while ((item= li++))
    item->split_sum_func(session, ref_pointer_array, fields, li.ref(), true);
}


table_map
Item_cond::used_tables() const
{
  return used_tables_cache;
}


void Item_cond::update_used_tables()
{
  List<Item>::iterator li(list.begin());
  Item *item;

  used_tables_cache=0;
  const_item_cache= true;
  while ((item=li++))
  {
    item->update_used_tables();
    used_tables_cache|= item->used_tables();
    const_item_cache&= item->const_item();
  }
}


void Item_cond::print(String *str)
{
  str->append('(');
  List<Item>::iterator li(list.begin());
  Item *item;
  if ((item=li++))
    item->print(str);
  while ((item=li++))
  {
    str->append(' ');
    str->append(func_name(), strlen(func_name()));
    str->append(' ');
    item->print(str);
  }
  str->append(')');
}


void Item_cond::neg_arguments(Session *session)
{
  List<Item>::iterator li(list.begin());
  Item *item;
  while ((item= li++))
  {
    Item *new_item= item->neg_transformer(session);
    if (!new_item)
      new_item= new Item_func_not(item);
    li.replace(new_item);
  }
}
# 4228 "drizzled/item/cmpfunc.cc"
int64_t Item_cond_and::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4230, __PRETTY_FUNCTION__));
  List<Item>::iterator li(list.begin());
  Item *item;
  null_value= 0;
  while ((item=li++))
  {
    if (!item->val_bool())
    {
      if (abort_on_null || !(null_value= item->null_value))
 return 0;
    }
  }
  return null_value ? 0 : 1;
}


int64_t Item_cond_or::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4248, __PRETTY_FUNCTION__));
  List<Item>::iterator li(list.begin());
  Item *item;
  null_value=0;
  while ((item=li++))
  {
    if (item->val_bool())
    {
      null_value=0;
      return 1;
    }
    if (item->null_value)
      null_value=1;
  }
  return 0;
}
# 4285 "drizzled/item/cmpfunc.cc"
Item *and_expressions(Item *a, Item *b, Item **org_item)
{
  if (!a)
    return (*org_item= (Item*) b);
  if (a == *org_item)
  {
    Item_cond *res;
    res= new Item_cond_and(a, (Item*) b);
    res->used_tables_cache= a->used_tables() | b->used_tables();
    res->not_null_tables_cache= a->not_null_tables() | b->not_null_tables();
    return res;
  }
  ((Item_cond_and*) a)->add((Item*) b);
  ((Item_cond_and*) a)->used_tables_cache|= b->used_tables();
  ((Item_cond_and*) a)->not_null_tables_cache|= b->not_null_tables();
  return a;
}


int64_t Item_func_isnull::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4306, __PRETTY_FUNCTION__));




  if (!used_tables_cache && !with_subselect)
    return cached_value;
  return args[0]->is_null() ? 1: 0;
}

int64_t Item_is_not_null_test::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4318, __PRETTY_FUNCTION__));
  if (!used_tables_cache && !with_subselect)
  {
    owner->was_null|= (!cached_value);
    return(cached_value);
  }
  if (args[0]->is_null())
  {
    owner->was_null|= 1;
    return 0;
  }
  else
    return 1;
}




void Item_is_not_null_test::update_used_tables()
{
  if (!args[0]->maybe_null)
  {
    used_tables_cache= 0;
    cached_value= (int64_t) 1;
  }
  else
  {
    args[0]->update_used_tables();
    if (!(used_tables_cache=args[0]->used_tables()) && !with_subselect)
    {

      cached_value= (int64_t) !args[0]->is_null();
    }
  }
}


int64_t Item_func_isnotnull::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4357, __PRETTY_FUNCTION__));
  return args[0]->is_null() ? 0 : 1;
}


void Item_func_isnotnull::print(String *str)
{
  str->append('(');
  args[0]->print(str);
  str->append((" is not null)"), (sizeof(" is not null)") - 1));
}


int64_t Item_func_like::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4372, __PRETTY_FUNCTION__));
  String* res = args[0]->val_str(&tmp_value1);
  if (args[0]->null_value)
  {
    null_value=1;
    return 0;
  }
  String* res2 = args[1]->val_str(&tmp_value2);
  if (args[1]->null_value)
  {
    null_value=1;
    return 0;
  }
  null_value=0;
  if (canDoTurboBM)
    return turboBM_matches(res->ptr(), res->length()) ? 1 : 0;
  return my_wildcmp(cmp.cmp_collation.collation,
       res->ptr(),res->ptr()+res->length(),
      res2->ptr(),res2->ptr()+res2->length(),
      make_escape_code(cmp.cmp_collation.collation, escape), internal::wild_one,internal::wild_many) ? 0 : 1;
}






Item_func::optimize_type Item_func_like::select_optimize() const
{
  if (args[1]->const_item())
  {
    String* res2= args[1]->val_str((String *)&tmp_value2);

    if (!res2)
      return OPTIMIZE_NONE;

    if (*res2->ptr() != internal::wild_many)
    {
      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != internal::wild_one)
 return OPTIMIZE_OP;
    }
  }
  return OPTIMIZE_NONE;
}


bool Item_func_like::fix_fields(Session *session, Item **ref)
{
  ((fixed == 0) ? static_cast<void> (0) : __assert_fail ("fixed == 0", "drizzled/item/cmpfunc.cc", 4420, __PRETTY_FUNCTION__));
  if (Item_bool_func2::fix_fields(session, ref) ||
      escape_item->fix_fields(session, &escape_item))
    return true;

  if (!escape_item->const_during_execution())
  {
    my_error(ER_WRONG_ARGUMENTS,(static_cast<drizzled::myf>(0)),"ESCAPE");
    return true;
  }

  if (escape_item->const_item())
  {


    String *escape_str= escape_item->val_str(&tmp_value1);
    if (escape_str)
    {
      escape= (char *)memory::sql_alloc(escape_str->length());
      strcpy(escape, escape_str->ptr());
    }
    else
    {
      escape= (char *)memory::sql_alloc(1);
      strcpy(escape, "\\");
    }





    if (args[1]->const_item() && not collation.collation->use_strnxfrm())
    {
      String* res2 = args[1]->val_str(&tmp_value2);
      if (!res2)
        return false;

      const size_t len = res2->length();
      const char* first = res2->ptr();
      const char* last = first + len - 1;





      if (len > 3 + 2 &&
          *first == internal::wild_many &&
          *last == internal::wild_many)
      {
        const char* tmp = first + 1;
        for (; *tmp != internal::wild_many && *tmp != internal::wild_one; tmp++)
        {
          if (escape == tmp)
            break;
        }

        canDoTurboBM = (tmp == last) && !use_mb(args[0]->collation.collation);
      }
      if (canDoTurboBM)
      {
        pattern = first + 1;
        pattern_len = (int) len - 2;
        int *suff = (int*) session->mem.alloc(sizeof(int) * ((pattern_len + 1)*2+ alphabet_size));
        bmGs = suff + pattern_len + 1;
        bmBc = bmGs + pattern_len + 1;
        turboBM_compute_good_suffix_shifts(suff);
        turboBM_compute_bad_character_shifts();
      }
    }
  }
  return false;
}

void Item_func_like::cleanup()
{
  canDoTurboBM= false;
  Item_bool_func2::cleanup();
}

static unsigned char likeconv(const charset_info_st *cs, unsigned char a)
{



  return cs->sort_order[a];

}





void Item_func_like::turboBM_compute_suffixes(int *suff)
{
  const int plm1 = pattern_len - 1;
  int f = 0;
  int g = plm1;
  int *const splm1 = suff + plm1;
  const charset_info_st * const cs= cmp.cmp_collation.collation;

  *splm1 = pattern_len;

  if (!cs->sort_order)
  {
    for (int i = pattern_len - 2; i >= 0; i--)
    {
      int tmp = *(splm1 + i - f);
      if (g < i && tmp < i - g)
        suff[i] = tmp;
      else
      {
        if (i < g)
          g = i;
        f = i;
        while (g >= 0 && pattern[g] == pattern[g + plm1 - f])
          g--;
        suff[i] = f - g;
      }
    }
  }
  else
  {
    for (int i = pattern_len - 2; 0 <= i; --i)
    {
      int tmp = *(splm1 + i - f);
      if (g < i && tmp < i - g)
        suff[i] = tmp;
      else
      {
        if (i < g)
          g = i;
        f = i;
        while (g >= 0 &&
               likeconv(cs, pattern[g]) == likeconv(cs, pattern[g + plm1 - f]))
          g--;
        suff[i] = f - g;
      }
    }
  }
}






void Item_func_like::turboBM_compute_good_suffix_shifts(int *suff)
{
  turboBM_compute_suffixes(suff);

  int *end = bmGs + pattern_len;
  int *k;
  for (k = bmGs; k < end; k++)
    *k = pattern_len;

  int tmp;
  int i;
  int j = 0;
  const int plm1 = pattern_len - 1;
  for (i = plm1; i > -1; i--)
  {
    if (suff[i] == i + 1)
    {
      for (tmp = plm1 - i; j < tmp; j++)
      {
 int *tmp2 = bmGs + j;
 if (*tmp2 == pattern_len)
   *tmp2 = tmp;
      }
    }
  }

  int *tmp2;
  for (tmp = plm1 - i; j < tmp; j++)
  {
    tmp2 = bmGs + j;
    if (*tmp2 == pattern_len)
      *tmp2 = tmp;
  }

  tmp2 = bmGs + plm1;
  for (i = 0; i <= pattern_len - 2; i++)
    *(tmp2 - suff[i]) = plm1 - i;
}






void Item_func_like::turboBM_compute_bad_character_shifts()
{
  int *i;
  int *end = bmBc + alphabet_size;
  int j;
  const int plm1 = pattern_len - 1;
  const charset_info_st *const cs= cmp.cmp_collation.collation;

  for (i = bmBc; i < end; i++)
    *i = pattern_len;

  if (!cs->sort_order)
  {
    for (j = 0; j < plm1; j++)
      bmBc[(uint32_t) (unsigned char) pattern[j]] = plm1 - j;
  }
  else
  {
    for (j = 0; j < plm1; j++)
      bmBc[(uint32_t) likeconv(cs,pattern[j])] = plm1 - j;
  }
}
# 4641 "drizzled/item/cmpfunc.cc"
bool Item_func_like::turboBM_matches(const char* text, int text_len) const
{
  int bcShift;
  int turboShift;
  int shift = pattern_len;
  int j = 0;
  int u = 0;
  const charset_info_st * const cs= cmp.cmp_collation.collation;

  const int plm1= pattern_len - 1;
  const int tlmpl= text_len - pattern_len;


  if (!cs->sort_order)
  {
    while (j <= tlmpl)
    {
      int i= plm1;
      while (i >= 0 && pattern[i] == text[i + j])
      {
 i--;
 if (i == plm1 - shift)
   i-= u;
      }
      if (i < 0)
 return 1;

      const int v = plm1 - i;
      turboShift = u - v;
      bcShift = bmBc[(uint32_t) (unsigned char) text[i + j]] - plm1 + i;
      shift = (turboShift > bcShift) ? turboShift : bcShift;
      shift = (shift > bmGs[i]) ? shift : bmGs[i];
      if (shift == bmGs[i])
 u = (pattern_len - shift < v) ? pattern_len - shift : v;
      else
      {
        if (turboShift < bcShift)
          shift= max(shift, u + 1);
        u = 0;
      }
      j+= shift;
    }
    return 0;
  }
  else
  {
    while (j <= tlmpl)
    {
      int i = plm1;
      while (i >= 0 && likeconv(cs,pattern[i]) == likeconv(cs,text[i + j]))
      {
        i--;
        if (i == plm1 - shift)
          i-= u;
      }

      if (i < 0)
        return 1;

      const int v= plm1 - i;
      turboShift= u - v;
      bcShift= bmBc[(uint32_t) likeconv(cs, text[i + j])] - plm1 + i;
      shift= (turboShift > bcShift) ? turboShift : bcShift;
      shift= max(shift, bmGs[i]);

      if (shift == bmGs[i])
        u= (pattern_len - shift < v) ? pattern_len - shift : v;
      else
      {
        if (turboShift < bcShift)
          shift= max(shift, u + 1);
        u = 0;
      }

      j+= shift;
    }
    return 0;
  }
}
# 4738 "drizzled/item/cmpfunc.cc"
int64_t Item_cond_xor::val_int()
{
  ((fixed == 1) ? static_cast<void> (0) : __assert_fail ("fixed == 1", "drizzled/item/cmpfunc.cc", 4740, __PRETTY_FUNCTION__));
  List<Item>::iterator li(list.begin());
  Item *item;
  int result=0;
  null_value=0;
  while ((item=li++))
  {
    result^= (item->val_int() != 0);
    if (item->null_value)
    {
      null_value=1;
      return 0;
    }
  }
  return (int64_t) result;
}
# 4783 "drizzled/item/cmpfunc.cc"
Item *Item_func_not::neg_transformer(Session *)
{
  return args[0];
}


Item *Item_bool_rowready_func2::neg_transformer(Session *)
{
  Item *item= negated_item();
  return item;
}





Item *Item_func_isnull::neg_transformer(Session *)
{
  Item *item= new Item_func_isnotnull(args[0]);
  return item;
}





Item *Item_func_isnotnull::neg_transformer(Session *)
{
  Item *item= new Item_func_isnull(args[0]);
  return item;
}


Item *Item_cond_and::neg_transformer(Session *session)

{
  neg_arguments(session);
  Item *item= new Item_cond_or(list);
  return item;
}


Item *Item_cond_or::neg_transformer(Session *session)

{
  neg_arguments(session);
  Item *item= new Item_cond_and(list);
  return item;
}


Item *Item_func_nop_all::neg_transformer(Session *)
{

  Item_func_not_all *new_item= new Item_func_not_all(args[0]);
  Item_allany_subselect *allany= (Item_allany_subselect*)args[0];
  allany->func= allany->func_creator(false);
  allany->all= !allany->all;
  allany->upper_item= new_item;
  return new_item;
}

Item *Item_func_not_all::neg_transformer(Session *)
{

  Item_func_nop_all *new_item= new Item_func_nop_all(args[0]);
  Item_allany_subselect *allany= (Item_allany_subselect*)args[0];
  allany->all= !allany->all;
  allany->func= allany->func_creator(true);
  allany->upper_item= new_item;
  return new_item;
}

Item *Item_func_eq::negated_item()
{
  return new Item_func_ne(args[0], args[1]);
}


Item *Item_func_ne::negated_item()
{
  return new Item_func_eq(args[0], args[1]);
}


Item *Item_func_lt::negated_item()
{
  return new Item_func_ge(args[0], args[1]);
}


Item *Item_func_ge::negated_item()
{
  return new Item_func_lt(args[0], args[1]);
}


Item *Item_func_gt::negated_item()
{
  return new Item_func_le(args[0], args[1]);
}


Item *Item_func_le::negated_item()
{
  return new Item_func_gt(args[0], args[1]);
}




Item *Item_bool_rowready_func2::negated_item()
{
  ((0) ? static_cast<void> (0) : __assert_fail ("0", "drizzled/item/cmpfunc.cc", 4896, __PRETTY_FUNCTION__));
  return 0;
}

Item_equal::Item_equal(Item_field *f1, Item_field *f2)
  : item::function::Boolean(), const_item(0), eval_item(0), cond_false(0)
{
  const_item_cache= false;
  fields.push_back(f1);
  fields.push_back(f2);
}

Item_equal::Item_equal(Item *c, Item_field *f)
  : item::function::Boolean(), eval_item(0), cond_false(0)
{
  const_item_cache= false;
  fields.push_back(f);
  const_item= c;
}


Item_equal::Item_equal(Item_equal *item_equal)
  : item::function::Boolean(), eval_item(0), cond_false(0)
{
  const_item_cache= false;
  List<Item_field>::iterator li(item_equal->fields.begin());
  Item_field *item;
  while ((item= li++))
  {
    fields.push_back(item);
  }
  const_item= item_equal->const_item;
  cond_false= item_equal->cond_false;
}

void Item_equal::add(Item *c)
{
  if (cond_false)
    return;
  if (!const_item)
  {
    const_item= c;
    return;
  }
  Item_func_eq *func= new Item_func_eq(c, const_item);
  func->set_cmp_func();
  func->quick_fix_field();
  if ((cond_false= !func->val_int()))
    const_item_cache= true;
}

void Item_equal::add(Item_field *f)
{
  fields.push_back(f);
}

uint32_t Item_equal::members()
{
  return fields.size();
}
# 4971 "drizzled/item/cmpfunc.cc"
bool Item_equal::contains(Field *field)
{
  List<Item_field>::iterator it(fields.begin());
  Item_field *item;
  while ((item= it++))
  {
    if (field->eq(item->field))
        return 1;
  }
  return 0;
}
# 4995 "drizzled/item/cmpfunc.cc"
void Item_equal::merge(Item_equal *item)
{
  fields.concat(&item->fields);
  Item *c= item->const_item;
  if (c)
  {





    add(c);
  }
  cond_false|= item->cond_false;
}
# 5029 "drizzled/item/cmpfunc.cc"
void Item_equal::sort(Item_field_cmpfunc cmp, void *arg)
{
  bool swap;
  List<Item_field>::iterator it(fields.begin());
  do
  {
    Item_field *item1= it++;
    Item_field **ref1= it.ref();
    Item_field *item2;

    swap= false;
    while ((item2= it++))
    {
      Item_field **ref2= it.ref();
      if (cmp(item1, item2, arg) < 0)
      {
        Item_field *item= *ref1;
        *ref1= *ref2;
        *ref2= item;
        swap= true;
      }
      else
      {
        item1= item2;
        ref1= ref2;
      }
    }
    it= fields.begin();
  } while (swap);
}
# 5071 "drizzled/item/cmpfunc.cc"
void Item_equal::update_const()
{
  List<Item_field>::iterator it(fields.begin());
  Item *item;
  while ((item= it++))
  {
    if (item->const_item())
    {
      it.remove();
      add(item);
    }
  }
}

bool Item_equal::fix_fields(Session *, Item **)
{
  List<Item_field>::iterator li(fields.begin());
  Item *item;
  not_null_tables_cache= used_tables_cache= 0;
  const_item_cache= false;
  while ((item= li++))
  {
    table_map tmp_table_map;
    used_tables_cache|= item->used_tables();
    tmp_table_map= item->not_null_tables();
    not_null_tables_cache|= tmp_table_map;
    if (item->maybe_null)
      maybe_null=1;
  }
  fix_length_and_dec();
  fixed= 1;
  return 0;
}

void Item_equal::update_used_tables()
{
  List<Item_field>::iterator li(fields.begin());
  Item *item;
  not_null_tables_cache= used_tables_cache= 0;
  if ((const_item_cache= cond_false))
    return;
  while ((item=li++))
  {
    item->update_used_tables();
    used_tables_cache|= item->used_tables();
    const_item_cache&= item->const_item();
  }
}

int64_t Item_equal::val_int()
{
  Item_field *item_field;
  if (cond_false)
    return 0;
  List<Item_field>::iterator it(fields.begin());
  Item *item= const_item ? const_item : it++;
  eval_item->store_value(item);
  if ((null_value= item->null_value))
    return 0;
  while ((item_field= it++))
  {

    if (item_field->field->getTable()->const_table)
    {
      if (eval_item->cmp(item_field) || (null_value= item_field->null_value))
        return 0;
    }
  }
  return 1;
}

void Item_equal::fix_length_and_dec()
{
  Item *item= get_first();
  eval_item= cmp_item::get_comparator(item->result_type(),
                                      item->collation.collation);
}

bool Item_equal::walk(Item_processor processor, bool walk_subquery, unsigned char *arg)
{
  List<Item_field>::iterator it(fields.begin());
  Item *item;
  while ((item= it++))
  {
    if (item->walk(processor, walk_subquery, arg))
      return 1;
  }
  return Item_func::walk(processor, walk_subquery, arg);
}

Item *Item_equal::transform(Item_transformer transformer, unsigned char *arg)
{
  List<Item_field>::iterator it(fields.begin());
  Item *item;
  while ((item= it++))
  {
    Item *new_item= item->transform(transformer, arg);
    if (!new_item)
      return 0;
    *(Item **)it.ref()= new_item;
  }
  return Item_func::transform(transformer, arg);
}

void Item_equal::print(String *str)
{
  str->append(func_name(), strlen(func_name()));
  str->append('(');
  List<Item_field>::iterator it(fields.begin());
  Item *item;
  if (const_item)
    const_item->print(str);
  else
  {
    item= it++;
    item->print(str);
  }
  while ((item= it++))
  {
    str->append(',');
    str->append(' ');
    item->print(str);
  }
  str->append(')');
}

cmp_item_datetime::cmp_item_datetime(Item *warn_item_arg) :
  session(::drizzled::_current_session()),
  warn_item(warn_item_arg),
  lval_cache(0)
{}

}