// /usr/libexec/gcc/x86_64-redhat-linux/4.8.2/cc1plus -quiet -I /opt/sevenflow/boost/include/ -D_GNU_SOURCE test.cpp -quiet -dumpbase test.cpp -mtune=generic -march=x86-64 -auxbase test -o - -frandom-seed=0
# 1 "test.cpp"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "test.cpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/config.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/user.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/config.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/config/select_compiler_config.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/config.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/config/compiler/gcc.hpp" 1
# 36 "/opt/sevenflow/boost/include/boost/config.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/config/select_stdlib_config.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/config/select_stdlib_config.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3

# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 1 3


# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 4 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
# 1855 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
  typedef long unsigned int size_t;
  typedef long int ptrdiff_t;




}
# 2097 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 1 3
# 39 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 375 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 385 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 386 "/usr/include/sys/cdefs.h" 2 3 4
# 376 "/usr/include/features.h" 2 3 4
# 399 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 3 4
# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/gnu/stubs.h" 2 3 4
# 400 "/usr/include/features.h" 2 3 4
# 40 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/os_defines.h" 2 3
# 2098 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3


# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
# 2101 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h" 2 3
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 147 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 212 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 19 "/opt/sevenflow/boost/include/boost/config/select_stdlib_config.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/config/select_stdlib_config.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/no_tr1/utility.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/config/no_tr1/utility.hpp"
# 1 "/usr/include/c++/4.8.2/utility" 1 3
# 58 "/usr/include/c++/4.8.2/utility" 3
       
# 59 "/usr/include/c++/4.8.2/utility" 3
# 69 "/usr/include/c++/4.8.2/utility" 3
# 1 "/usr/include/c++/4.8.2/bits/stl_relops.h" 1 3
# 67 "/usr/include/c++/4.8.2/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
  namespace rel_ops
  {
 
# 85 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/utility" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_pair.h" 1 3
# 59 "/usr/include/c++/4.8.2/bits/stl_pair.h" 3
# 1 "/usr/include/c++/4.8.2/bits/move.h" 1 3
# 34 "/usr/include/c++/4.8.2/bits/move.h" 3
# 1 "/usr/include/c++/4.8.2/bits/concept_check.h" 1 3
# 33 "/usr/include/c++/4.8.2/bits/concept_check.h" 3
       
# 34 "/usr/include/c++/4.8.2/bits/concept_check.h" 3
# 35 "/usr/include/c++/4.8.2/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.2/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 164 "/usr/include/c++/4.8.2/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.2/bits/stl_pair.h" 2 3





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

# 95 "/usr/include/c++/4.8.2/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.2/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.2/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.2/utility" 2 3
# 22 "/opt/sevenflow/boost/include/boost/config/no_tr1/utility.hpp" 2
# 38 "/opt/sevenflow/boost/include/boost/config/select_stdlib_config.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/config.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/config/stdlib/libstdcpp3.hpp" 1
# 76 "/opt/sevenflow/boost/include/boost/config/stdlib/libstdcpp3.hpp"
# 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/bits/posix_opt.h" 1 3 4
# 203 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 22 "/usr/include/bits/environments.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/environments.h" 2 3 4
# 207 "/usr/include/unistd.h" 2 3 4
# 217 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 27 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/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;

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







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


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

typedef int __daddr_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;


typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;


typedef long int __fsword_t;

typedef long int __ssize_t;


typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;



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


typedef long int __intptr_t;


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


typedef __ssize_t ssize_t;





# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/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 __off_t off_t;






typedef __off64_t off64_t;




typedef __useconds_t useconds_t;




typedef __pid_t pid_t;






typedef __intptr_t intptr_t;






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))) ;
# 334 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
# 345 "/usr/include/unistd.h" 3 4
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) ;





extern ssize_t write (int __fd, const void *__buf, size_t __n) ;
# 376 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
        __off_t __offset) ;






extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
         __off_t __offset) ;
# 404 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset) ;


extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
    __off64_t __offset) ;







extern int pipe (int __pipedes[2]) throw () ;




extern int pipe2 (int __pipedes[2], int __flags) throw () ;
# 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))) ;



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ;




extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
     throw () __attribute__ ((__nonnull__ (1))) ;






extern int fchownat (int __fd, const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     throw () __attribute__ ((__nonnull__ (2))) ;



extern int chdir (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;



extern int fchdir (int __fd) throw () ;
# 511 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) throw () ;





extern char *get_current_dir_name (void) throw ();







extern char *getwd (char *__buf)
     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) ;




extern int dup (int __fd) throw () ;


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




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 25 "/usr/include/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 () ;



extern int group_member (__gid_t __gid) throw ();






extern int setuid (__uid_t __uid) throw () ;




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




extern int seteuid (__uid_t __uid) throw () ;






extern int setgid (__gid_t __gid) throw () ;




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




extern int setegid (__gid_t __gid) throw () ;





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     throw ();



extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
     throw ();



extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
     throw () ;



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






extern __pid_t fork (void) throw ();







extern __pid_t vfork (void) throw ();





extern char *ttyname (int __fd) throw ();



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     throw () __attribute__ ((__nonnull__ (2))) ;



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




extern int linkat (int __fromfd, const char *__from, int __tofd,
     const char *__to, int __flags)
     throw () __attribute__ ((__nonnull__ (2, 4))) ;




extern int symlink (const char *__from, const char *__to)
     throw () __attribute__ ((__nonnull__ (1, 2))) ;




extern ssize_t readlink (const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (1, 2))) ;




extern int symlinkat (const char *__from, int __tofd,
        const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) ;


extern ssize_t readlinkat (int __fd, const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     throw () __attribute__ ((__nonnull__ (2, 3))) ;



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



extern int sethostid (long int __id) throw () ;





extern int getdomainname (char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) ;
extern int setdomainname (const char *__name, size_t __len)
     throw () __attribute__ ((__nonnull__ (1))) ;





extern int vhangup (void) throw ();


extern int revoke (const char *__file) throw () __attribute__ ((__nonnull__ (1))) ;







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






extern int chroot (const char *__path) throw () __attribute__ ((__nonnull__ (1))) ;



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 ();
# 1015 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 1027 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 1038 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) throw () ;
# 1048 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) throw () ;
# 1059 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) throw () ;





extern void *sbrk (intptr_t __delta) throw ();
# 1080 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) throw ();
# 1103 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1113 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 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 *__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)));
# 1172 "/usr/include/unistd.h" 3 4
}
# 77 "/opt/sevenflow/boost/include/boost/config/stdlib/libstdcpp3.hpp" 2
# 45 "/opt/sevenflow/boost/include/boost/config.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/config/select_platform_config.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/config.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/config/platform/linux.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/config/platform/linux.hpp"
# 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
# 39 "/usr/include/c++/4.8.2/cstdlib" 3
       
# 40 "/usr/include/c++/4.8.2/cstdlib" 3
# 72 "/usr/include/c++/4.8.2/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 32 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 33 "/usr/include/stdlib.h" 2 3 4

extern "C" {






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






# 1 "/usr/include/bits/byteswap-16.h" 1 3 4
# 36 "/usr/include/bits/byteswap.h" 2 3 4
# 44 "/usr/include/bits/byteswap.h" 3 4
static __inline unsigned int
__bswap_32 (unsigned int __bsx)
{
  return __builtin_bswap32 (__bsx);
}
# 108 "/usr/include/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/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 () ;




extern double atof (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern int atoi (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern long int atol (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;





__extension__ extern long long int atoll (const char *__nptr)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;





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)));
# 305 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () ;


extern long int a64l (const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;




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






typedef __ino64_t ino64_t;




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




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





typedef __key_t key_t;
# 132 "/usr/include/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/sys/types.h" 2 3 4







typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 147 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 194 "/usr/include/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));


typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));

typedef int register_t __attribute__ ((__mode__ (__word__)));
# 219 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 30 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 22 "/usr/include/bits/select.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/select.h" 2 3 4
# 31 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 23 "/usr/include/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/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/sys/select.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 30 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 46 "/usr/include/sys/select.h" 2 3 4
# 54 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 64 "/usr/include/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/sys/select.h" 3 4
extern "C" {
# 106 "/usr/include/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/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);
# 131 "/usr/include/sys/select.h" 3 4
}
# 220 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 29 "/usr/include/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__));
# 63 "/usr/include/sys/sysmacros.h" 3 4
}
# 223 "/usr/include/sys/types.h" 2 3 4





typedef __blksize_t blksize_t;






typedef __blkcnt_t blkcnt_t;



typedef __fsblkcnt_t fsblkcnt_t;



typedef __fsfilcnt_t fsfilcnt_t;
# 262 "/usr/include/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





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


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

typedef union pthread_attr_t pthread_attr_t;





typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;
# 90 "/usr/include/bits/pthreadtypes.h" 3 4
typedef union
{
  struct __pthread_mutex_s
  {
    int __lock;
    unsigned int __count;
    int __owner;

    unsigned int __nusers;



    int __kind;

    int __spins;
    __pthread_list_t __list;
# 115 "/usr/include/bits/pthreadtypes.h" 3 4
  } __data;
  char __size[40];
  long int __align;
} pthread_mutex_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_mutexattr_t;




typedef union
{
  struct
  {
    int __lock;
    unsigned int __futex;
    __extension__ unsigned long long int __total_seq;
    __extension__ unsigned long long int __wakeup_seq;
    __extension__ unsigned long long int __woken_seq;
    void *__mutex;
    unsigned int __nwaiters;
    unsigned int __broadcast_seq;
  } __data;
  char __size[48];
  __extension__ long long int __align;
} pthread_cond_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_condattr_t;



typedef unsigned int pthread_key_t;



typedef int pthread_once_t;





typedef union
{

  struct
  {
    int __lock;
    unsigned int __nr_readers;
    unsigned int __readers_wakeup;
    unsigned int __writer_wakeup;
    unsigned int __nr_readers_queued;
    unsigned int __nr_writers_queued;
    int __writer;
    int __shared;
    unsigned long int __pad1;
    unsigned long int __pad2;


    unsigned int __flags;

  } __data;
# 202 "/usr/include/bits/pthreadtypes.h" 3 4
  char __size[56];
  long int __align;
} pthread_rwlock_t;

typedef union
{
  char __size[8];
  long int __align;
} pthread_rwlockattr_t;





typedef volatile int pthread_spinlock_t;




typedef union
{
  char __size[32];
  long int __align;
} pthread_barrier_t;

typedef union
{
  char __size[4];
  int __align;
} pthread_barrierattr_t;
# 271 "/usr/include/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__)) ;

extern void *calloc (size_t __nmemb, size_t __size)
     throw () __attribute__ ((__malloc__)) ;










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/x86_64-redhat-linux/4.8.2/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__)) ;




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     throw () __attribute__ ((__nonnull__ (1))) ;




extern void *aligned_alloc (size_t __alignment, size_t __size)
     throw () __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))) ;





extern char *secure_getenv (const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) ;






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)));
# 619 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 629 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 641 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 651 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) ;
# 662 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 673 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 683 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 693 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 705 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;









extern int system (const char *__command) ;






extern char *canonicalize_file_name (const char *__name)
     throw () __attribute__ ((__nonnull__ (1))) ;
# 733 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
         char *__restrict __resolved) throw () ;






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



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__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;



__extension__ extern long long int llabs (long long int __x)
     throw () __attribute__ ((__const__)) ;







extern div_t div (int __numer, int __denom)
     throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
     throw () __attribute__ ((__const__)) ;




__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     throw () __attribute__ ((__const__)) ;

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




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;




extern char *gcvt (double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) ;




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     throw () __attribute__ ((__nonnull__ (3))) ;




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


extern int mbtowc (wchar_t *__restrict __pwc,
     const char *__restrict __s, size_t __n) throw () ;


extern int wctomb (char *__s, wchar_t __wchar) throw () ;



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





extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));







extern int posix_openpt (int __oflag) ;







extern int grantpt (int __fd) throw ();



extern int unlockpt (int __fd) throw ();




extern char *ptsname (int __fd) throw () ;






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/bits/stdlib-float.h" 1 3 4
# 952 "/usr/include/stdlib.h" 2 3 4
# 964 "/usr/include/stdlib.h" 3 4
}
# 73 "/usr/include/c++/4.8.2/cstdlib" 2 3
# 114 "/usr/include/c++/4.8.2/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); }



  inline __int128
  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }



}
# 196 "/usr/include/c++/4.8.2/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.2/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 "/opt/sevenflow/boost/include/boost/config/platform/linux.hpp" 2
# 74 "/opt/sevenflow/boost/include/boost/config/platform/linux.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/posix_features.hpp" 1
# 75 "/opt/sevenflow/boost/include/boost/config/platform/linux.hpp" 2
# 54 "/opt/sevenflow/boost/include/boost/config.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/config/suffix.hpp" 1
# 33 "/opt/sevenflow/boost/include/boost/config/suffix.hpp"
       
# 34 "/opt/sevenflow/boost/include/boost/config/suffix.hpp" 3
# 481 "/opt/sevenflow/boost/include/boost/config/suffix.hpp" 3
namespace boost{

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




}
# 58 "/opt/sevenflow/boost/include/boost/config.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/workaround.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/workaround.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/detail/workaround.hpp" 2
# 133 "/opt/sevenflow/boost/include/boost/interprocess/detail/workaround.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 134 "/opt/sevenflow/boost/include/boost/interprocess/detail/workaround.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 22 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2







namespace boost{
namespace intrusive{
}}

namespace boost{
namespace interprocess{
namespace bi = boost::intrusive;
}}


# 1 "/usr/include/c++/4.8.2/memory" 1 3
# 46 "/usr/include/c++/4.8.2/memory" 3
       
# 47 "/usr/include/c++/4.8.2/memory" 3
# 62 "/usr/include/c++/4.8.2/memory" 3
# 1 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 1 3
# 60 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 3
# 1 "/usr/include/c++/4.8.2/bits/functexcept.h" 1 3
# 40 "/usr/include/c++/4.8.2/bits/functexcept.h" 3
# 1 "/usr/include/c++/4.8.2/bits/exception_defines.h" 1 3
# 41 "/usr/include/c++/4.8.2/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.2/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 1 3
# 35 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
       
# 36 "/usr/include/c++/4.8.2/bits/cpp_type_traits.h" 3
# 68 "/usr/include/c++/4.8.2/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.2/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.2/bits/cpp_type_traits.h" 3

}
# 62 "/usr/include/c++/4.8.2/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8.2/ext/type_traits.h" 1 3
# 32 "/usr/include/c++/4.8.2/ext/type_traits.h" 3
       
# 33 "/usr/include/c++/4.8.2/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.2/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 1 3
# 32 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3
       
# 33 "/usr/include/c++/4.8.2/ext/numeric_traits.h" 3




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

# 54 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_algobase.h" 2 3

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







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

# 89 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/stl_iterator_base_types.h" 3

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


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




namespace __gnu_debug
{
  using namespace std::__debug;
}
# 66 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/stl_iterator_base_funcs.h" 3

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

# 95 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/memory" 2 3
# 1 "/usr/include/c++/4.8.2/bits/allocator.h" 1 3
# 46 "/usr/include/c++/4.8.2/bits/allocator.h" 3
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 1 3
# 33 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 3
# 1 "/usr/include/c++/4.8.2/ext/new_allocator.h" 1 3
# 33 "/usr/include/c++/4.8.2/ext/new_allocator.h" 3
# 1 "/usr/include/c++/4.8.2/new" 1 3
# 37 "/usr/include/c++/4.8.2/new" 3
       
# 38 "/usr/include/c++/4.8.2/new" 3


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

#pragma GCC visibility push(default)


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

extern "C++" {

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


}

namespace __gnu_cxx
{

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


}

}

#pragma GCC visibility pop
# 41 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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/c++/4.8.2/x86_64-redhat-linux/bits/c++allocator.h" 2 3
# 47 "/usr/include/c++/4.8.2/bits/allocator.h" 2 3
# 1 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 1 3
# 46 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3
       
# 47 "/usr/include/c++/4.8.2/bits/memoryfwd.h" 3



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

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

  template<>
    class allocator<void>;


  template<typename, typename>
    struct uses_allocator;




}
# 48 "/usr/include/c++/4.8.2/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.2/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.2/bits/allocator.h" 3

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

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



  {
    typedef _Alloc allocator_type;
# 199 "/usr/include/c++/4.8.2/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.2/bits/stl_construct.h" 2 3

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

# 77 "/usr/include/c++/4.8.2/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.2/memory" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_uninitialized.h" 1 3
# 59 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/stl_uninitialized.h" 3

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

# 83 "/usr/include/c++/4.8.2/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.2/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.2/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.2/memory" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_raw_storage_iter.h" 1 3
# 59 "/usr/include/c++/4.8.2/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.2/memory" 2 3
# 87 "/usr/include/c++/4.8.2/memory" 3
# 1 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 1 3
# 36 "/usr/include/c++/4.8.2/backward/auto_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 47 "/usr/include/c++/4.8.2/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.2/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.2/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 124 "/usr/include/c++/4.8.2/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.2/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 152 "/usr/include/c++/4.8.2/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.2/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 180 "/usr/include/c++/4.8.2/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.2/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 224 "/usr/include/c++/4.8.2/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.2/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.2/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.2/backward/auto_ptr.h" 3

}
# 88 "/usr/include/c++/4.8.2/memory" 2 3
# 40 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/functional" 1 3
# 46 "/usr/include/c++/4.8.2/functional" 3
       
# 47 "/usr/include/c++/4.8.2/functional" 3


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

# 100 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/backward/binders.h" 1 3
# 59 "/usr/include/c++/4.8.2/backward/binders.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 103 "/usr/include/c++/4.8.2/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.2/bits/stl_function.h" 2 3
# 50 "/usr/include/c++/4.8.2/functional" 2 3
# 41 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/iosfwd" 1 3
# 36 "/usr/include/c++/4.8.2/iosfwd" 3
       
# 37 "/usr/include/c++/4.8.2/iosfwd" 3


# 1 "/usr/include/c++/4.8.2/bits/stringfwd.h" 1 3
# 37 "/usr/include/c++/4.8.2/bits/stringfwd.h" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/bits/stringfwd.h" 3

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

# 1 "/usr/include/c++/4.8.2/cwchar" 1 3
# 39 "/usr/include/c++/4.8.2/cwchar" 3
       
# 40 "/usr/include/c++/4.8.2/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/x86_64-redhat-linux/4.8.2/include/stdarg.h" 1 3 4
# 40 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 40 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 22 "/usr/include/bits/wchar.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/wchar.h" 2 3 4
# 42 "/usr/include/wchar.h" 2 3 4
# 51 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 353 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/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 ();

# 405 "/usr/include/wchar.h" 3 4



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 ();
# 891 "/usr/include/wchar.h" 3 4
}
# 45 "/usr/include/c++/4.8.2/cwchar" 2 3
# 62 "/usr/include/c++/4.8.2/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 135 "/usr/include/c++/4.8.2/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.2/cwchar" 3

}







namespace __gnu_cxx
{





  using ::wcstold;
# 257 "/usr/include/c++/4.8.2/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.2/bits/postypes.h" 2 3
# 68 "/usr/include/c++/4.8.2/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 88 "/usr/include/c++/4.8.2/bits/postypes.h" 3
  typedef long streamoff;
# 98 "/usr/include/c++/4.8.2/bits/postypes.h" 3
  typedef ptrdiff_t streamsize;
# 111 "/usr/include/c++/4.8.2/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.2/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.2/bits/postypes.h" 3

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

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

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




}
# 42 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/string" 1 3
# 36 "/usr/include/c++/4.8.2/string" 3
       
# 37 "/usr/include/c++/4.8.2/string" 3



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



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




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

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

# 57 "/usr/include/c++/4.8.2/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.2/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.2/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.2/string" 2 3


# 1 "/usr/include/c++/4.8.2/bits/localefwd.h" 1 3
# 37 "/usr/include/c++/4.8.2/bits/localefwd.h" 3
       
# 38 "/usr/include/c++/4.8.2/bits/localefwd.h" 3


# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 1 3
# 39 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3
       
# 40 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++locale.h" 3

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


# 1 "/usr/include/locale.h" 1 3 4
# 29 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/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.2/clocale" 2 3
# 51 "/usr/include/c++/4.8.2/clocale" 3
namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/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.2/bits/localefwd.h" 2 3

# 1 "/usr/include/c++/4.8.2/cctype" 1 3
# 39 "/usr/include/c++/4.8.2/cctype" 3
       
# 40 "/usr/include/c++/4.8.2/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.2/cctype" 2 3
# 62 "/usr/include/c++/4.8.2/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.2/bits/localefwd.h" 2 3

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

# 55 "/usr/include/c++/4.8.2/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;


}
# 44 "/usr/include/c++/4.8.2/string" 2 3
# 1 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 1 3
# 33 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 3
       
# 34 "/usr/include/c++/4.8.2/bits/ostream_insert.h" 3


# 1 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 1 3
# 34 "/usr/include/c++/4.8.2/bits/cxxabi_forced.h" 3
       
# 35 "/usr/include/c++/4.8.2/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.2/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.2/string" 2 3






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

# 1 "/usr/include/c++/4.8.2/ext/atomicity.h" 1 3
# 32 "/usr/include/c++/4.8.2/ext/atomicity.h" 3
       
# 33 "/usr/include/c++/4.8.2/ext/atomicity.h" 3


# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 1 3
# 30 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 148 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 3
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 1 3
# 35 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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/x86_64-redhat-linux/4.8.2/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/bits/sched.h" 1 3 4
# 73 "/usr/include/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/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/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 () ;
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/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 38 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 86 "/usr/include/bits/time.h" 3 4
# 1 "/usr/include/bits/timex.h" 1 3 4
# 25 "/usr/include/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/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/bits/setjmp.h" 1 3 4
# 26 "/usr/include/bits/setjmp.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 27 "/usr/include/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/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 ();
# 1150 "/usr/include/pthread.h" 3 4
}
# 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 2 3
# 47 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/bits/gthr-default.h" 3
static __typeof(pthread_key_create) __gthrw___pthread_key_create __attribute__ ((__weakref__("__pthread_key_create")));
# 246 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/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/c++/4.8.2/x86_64-redhat-linux/bits/gthr.h" 2 3


#pragma GCC visibility pop
# 36 "/usr/include/c++/4.8.2/ext/atomicity.h" 2 3
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/atomic_word.h" 1 3
# 32 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 37 "/usr/include/c++/4.8.2/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); }
# 64 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 2 3





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

# 111 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 604 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 752 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }
# 775 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
      size_type
      capacity() const
      { return _M_rep()->_M_capacity; }
# 796 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const
      {
 ;
 return _M_data()[__pos];
      }
# 842 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {

 ;

 ;
 _M_leak();
 return _M_data()[__pos];
      }
# 863 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/basic_string.h" 3
      basic_string&
      append(const basic_string& __str);
# 988 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c);
# 1042 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n);
# 1127 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);
# 1295 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/basic_string.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1428 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1789 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
      void
      swap(basic_string& __s);
# 1799 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;
# 1845 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const ;
# 1890 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 1920 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const ;
# 1951 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const
 ;
# 2141 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const
 ;
# 2205 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 2282 "/usr/include/c++/4.8.2/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.2/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const;
# 2324 "/usr/include/c++/4.8.2/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2351 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/string" 2 3
# 1 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 1 3
# 40 "/usr/include/c++/4.8.2/bits/basic_string.tcc" 3
       
# 41 "/usr/include/c++/4.8.2/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.2/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.2/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.2/string" 2 3
# 43 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2



namespace boost { namespace interprocess {





class permissions;





class shared_memory_object;
# 68 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp"
class file_mapping;
class mapped_region;
class mapped_file;





class null_mutex;

class interprocess_mutex;
class interprocess_recursive_mutex;

class named_mutex;
class named_recursive_mutex;

class interprocess_semaphore;
class named_semaphore;





struct mutex_family;
struct null_mutex_family;





class barrier;
class interprocess_sharable_mutex;
class interprocess_condition;





template <class Mutex>
class scoped_lock;

template <class SharableMutex>
class sharable_lock;

template <class UpgradableMutex>
class upgradable_lock;





template<class T, class SegmentManager>
class allocator;

template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
class node_allocator;

template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
class private_node_allocator;

template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
class cached_node_allocator;

template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
         , unsigned char OverheadPercent = 5
>
class adaptive_pool;

template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
         , unsigned char OverheadPercent = 5
>
class private_adaptive_pool;

template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
         , unsigned char OverheadPercent = 5
>
class cached_adaptive_pool;






static const std::size_t offset_type_alignment = 0;

template <class T, class DifferenceType = std::ptrdiff_t, class OffsetType = std::size_t, std::size_t Alignment = offset_type_alignment>
class offset_ptr;






template<class MutexFamily, class VoidMutex = offset_ptr<void> >
class simple_seq_fit;

template<class MutexFamily, class VoidMutex = offset_ptr<void>, std::size_t MemAlignment = 0>
class rbtree_best_fit;





template<class IndexConfig> class flat_map_index;
template<class IndexConfig> class iset_index;
template<class IndexConfig> class iunordered_set_index;
template<class IndexConfig> class map_index;
template<class IndexConfig> class null_index;
template<class IndexConfig> class unordered_map_index;





template <class CharType
         ,class MemoryAlgorithm
         ,template<class IndexConfig> class IndexType>
class segment_manager;





template <class CharType
         ,class MemoryAlgorithm
         ,template<class IndexConfig> class IndexType>
class basic_managed_external_buffer;

typedef basic_managed_external_buffer
   <char
   ,rbtree_best_fit<null_mutex_family>
   ,iset_index>
managed_external_buffer;

typedef basic_managed_external_buffer
   <wchar_t
   ,rbtree_best_fit<null_mutex_family>
   ,iset_index>
wmanaged_external_buffer;





template <class CharType
         ,class MemoryAlgorithm
         ,template<class IndexConfig> class IndexType>
class basic_managed_shared_memory;

typedef basic_managed_shared_memory
   <char
   ,rbtree_best_fit<mutex_family>
   ,iset_index>
managed_shared_memory;

typedef basic_managed_shared_memory
   <wchar_t
   ,rbtree_best_fit<mutex_family>
   ,iset_index>
wmanaged_shared_memory;
# 257 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp"
template <class CharType
         ,class MemoryAlgorithm
         ,template<class IndexConfig> class IndexType>
class basic_managed_xsi_shared_memory;

typedef basic_managed_xsi_shared_memory
   <char
   ,rbtree_best_fit<mutex_family>
   ,iset_index>
managed_xsi_shared_memory;

typedef basic_managed_xsi_shared_memory
   <wchar_t
   ,rbtree_best_fit<mutex_family>
   ,iset_index>
wmanaged_xsi_shared_memory;







typedef basic_managed_shared_memory
   <char
   ,rbtree_best_fit<mutex_family, void*>
   ,iset_index>
fixed_managed_shared_memory;

typedef basic_managed_shared_memory
   <wchar_t
   ,rbtree_best_fit<mutex_family, void*>
   ,iset_index>
wfixed_managed_shared_memory;





template
   <class CharType
   ,class MemoryAlgorithm
   ,template<class IndexConfig> class IndexType>
class basic_managed_heap_memory;

typedef basic_managed_heap_memory
   <char
   ,rbtree_best_fit<null_mutex_family>
   ,iset_index>
managed_heap_memory;

typedef basic_managed_heap_memory
   <wchar_t
   ,rbtree_best_fit<null_mutex_family>
   ,iset_index>
wmanaged_heap_memory;





template
   <class CharType
   ,class MemoryAlgorithm
   ,template<class IndexConfig> class IndexType>
class basic_managed_mapped_file;

typedef basic_managed_mapped_file
   <char
   ,rbtree_best_fit<mutex_family>
   ,iset_index>
managed_mapped_file;

typedef basic_managed_mapped_file
   <wchar_t
   ,rbtree_best_fit<mutex_family>
   ,iset_index>
wmanaged_mapped_file;





class interprocess_exception;
class lock_exception;
class bad_alloc;






template <class CharT
         ,class CharTraits = std::char_traits<CharT> >
class basic_bufferbuf;

template <class CharT
         ,class CharTraits = std::char_traits<CharT> >
class basic_ibufferstream;

template <class CharT
         ,class CharTraits = std::char_traits<CharT> >
class basic_obufferstream;

template <class CharT
         ,class CharTraits = std::char_traits<CharT> >
class basic_bufferstream;





template <class CharVector
         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
class basic_vectorbuf;

template <class CharVector
         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
class basic_ivectorstream;

template <class CharVector
         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
class basic_ovectorstream;

template <class CharVector
         ,class CharTraits = std::char_traits<typename CharVector::value_type> >
class basic_vectorstream;





template<class T, class Deleter>
class scoped_ptr;

template<class T, class VoidPointer>
class intrusive_ptr;

template<class T, class VoidAllocator, class Deleter>
class shared_ptr;

template<class T, class VoidAllocator, class Deleter>
class weak_ptr;





template<class VoidPointer>
class message_queue_t;

typedef message_queue_t<offset_ptr<void> > message_queue;

}}





# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 417 "/opt/sevenflow/boost/include/boost/interprocess/interprocess_fwd.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/move/move.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/move/move.hpp"
# 1 "/usr/include/c++/4.8.2/algorithm" 1 3
# 58 "/usr/include/c++/4.8.2/algorithm" 3
       
# 59 "/usr/include/c++/4.8.2/algorithm" 3



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

# 203 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_heap.h" 1 3
# 61 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_heap.h" 3

}
# 62 "/usr/include/c++/4.8.2/bits/stl_algo.h" 2 3
# 71 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Iterator>
    void
    __move_median_to_first(_Iterator __result, _Iterator __a,
      _Iterator __b, _Iterator __c)
    {

     


      if (*__a < *__b)
 {
   if (*__b < *__c)
     std::iter_swap(__result, __b);
   else if (*__a < *__c)
     std::iter_swap(__result, __c);
   else
     std::iter_swap(__result, __a);
 }
      else if (*__a < *__c)
       std::iter_swap(__result, __a);
      else if (*__b < *__c)
 std::iter_swap(__result, __c);
      else
 std::iter_swap(__result, __b);
    }


  template<typename _Iterator, typename _Compare>
    void
    __move_median_to_first(_Iterator __result, _Iterator __a,
      _Iterator __b, _Iterator __c,
      _Compare __comp)
    {

     



      if (__comp(*__a, *__b))
 {
   if (__comp(*__b, *__c))
     std::iter_swap(__result, __b);
   else if (__comp(*__a, *__c))
     std::iter_swap(__result, __c);
   else
     std::iter_swap(__result, __a);
 }
      else if (__comp(*__a, *__c))
 std::iter_swap(__result, __a);
      else if (__comp(*__b, *__c))
 std::iter_swap(__result, __c);
      else
 std::iter_swap(__result, __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;
    }
# 351 "/usr/include/c++/4.8.2/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;
      _DistanceType __remainder = __count;

      while (__remainder <= __tailSize)
 {
   __first += __remainder;
   __tailSize -= __remainder;


   _RandomAccessIter __backTrack = __first;
   while (*--__backTrack == __val)
     {
       if (--__remainder == 0)
         return (__first - __count);
     }
   __remainder = __count + 1 - (__first - __backTrack);
 }
      return __last;
    }
# 421 "/usr/include/c++/4.8.2/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;
      _DistanceType __remainder = __count;

      while (__remainder <= __tailSize)
 {
   __first += __remainder;
   __tailSize -= __remainder;


   _RandomAccessIter __backTrack = __first;
   while (__binary_pred(*--__backTrack, __val))
     {
       if (--__remainder == 0)
         return (__first - __count);
     }
   __remainder = __count + 1 - (__first - __backTrack);
 }
      return __last;
    }


  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;
 }
    }
# 645 "/usr/include/c++/4.8.2/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));
    }
# 692 "/usr/include/c++/4.8.2/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);
    }
# 871 "/usr/include/c++/4.8.2/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;
    }
# 908 "/usr/include/c++/4.8.2/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;
    }
# 1089 "/usr/include/c++/4.8.2/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;
    }
# 1132 "/usr/include/c++/4.8.2/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;
    }
# 1172 "/usr/include/c++/4.8.2/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;
    }
# 1212 "/usr/include/c++/4.8.2/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;
 }
    }
# 1440 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1467 "/usr/include/c++/4.8.2/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);
     }
 }
    }
# 1673 "/usr/include/c++/4.8.2/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());
    }
# 1709 "/usr/include/c++/4.8.2/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;
 }
    }
# 1888 "/usr/include/c++/4.8.2/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);
    }
# 1972 "/usr/include/c++/4.8.2/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;
    }
# 2038 "/usr/include/c++/4.8.2/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_to_first(__first, __first + 1, __mid, (__last - 2));
      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_to_first(__first, __first + 1, __mid, (__last - 2),
      __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);
    }
# 2423 "/usr/include/c++/4.8.2/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;
    }
# 2470 "/usr/include/c++/4.8.2/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;
    }
# 2519 "/usr/include/c++/4.8.2/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;
    }
# 2572 "/usr/include/c++/4.8.2/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);
    }
# 2634 "/usr/include/c++/4.8.2/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);
    }
# 2695 "/usr/include/c++/4.8.2/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);
    }
# 2728 "/usr/include/c++/4.8.2/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);
    }
# 3152 "/usr/include/c++/4.8.2/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()));
    }
# 3207 "/usr/include/c++/4.8.2/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);
    }
# 3547 "/usr/include/c++/4.8.2/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;
    }
# 3597 "/usr/include/c++/4.8.2/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;
    }
# 3652 "/usr/include/c++/4.8.2/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;
     }
 }
    }
# 3709 "/usr/include/c++/4.8.2/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;
     }
 }
    }
# 3765 "/usr/include/c++/4.8.2/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;
     }
 }
    }
# 3822 "/usr/include/c++/4.8.2/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;
     }
 }
    }
# 3882 "/usr/include/c++/4.8.2/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;
    }
# 3919 "/usr/include/c++/4.8.2/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;
    }
# 4393 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3



# 4409 "/usr/include/c++/4.8.2/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);
    }
# 4430 "/usr/include/c++/4.8.2/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));
    }
# 4454 "/usr/include/c++/4.8.2/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));
    }
# 4484 "/usr/include/c++/4.8.2/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;
    }
# 4524 "/usr/include/c++/4.8.2/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;
    }
# 4556 "/usr/include/c++/4.8.2/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;
    }
# 4588 "/usr/include/c++/4.8.2/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;
    }
# 4620 "/usr/include/c++/4.8.2/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;
    }
# 4645 "/usr/include/c++/4.8.2/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;
    }
# 4687 "/usr/include/c++/4.8.2/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;
    }
# 4758 "/usr/include/c++/4.8.2/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;
    }
# 4833 "/usr/include/c++/4.8.2/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));
    }
# 4870 "/usr/include/c++/4.8.2/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));
    }
# 4912 "/usr/include/c++/4.8.2/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;
    }
# 4949 "/usr/include/c++/4.8.2/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;
    }
# 4982 "/usr/include/c++/4.8.2/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;
    }
# 5014 "/usr/include/c++/4.8.2/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;
    }
# 5046 "/usr/include/c++/4.8.2/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 5077 "/usr/include/c++/4.8.2/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;
    }
# 5114 "/usr/include/c++/4.8.2/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));
    }
# 5153 "/usr/include/c++/4.8.2/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));
    }
# 5185 "/usr/include/c++/4.8.2/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)));
    }
# 5213 "/usr/include/c++/4.8.2/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));
    }
# 5249 "/usr/include/c++/4.8.2/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));
    }
# 5283 "/usr/include/c++/4.8.2/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);
    }
# 5322 "/usr/include/c++/4.8.2/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);
    }
# 5359 "/usr/include/c++/4.8.2/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);
    }
# 5398 "/usr/include/c++/4.8.2/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);
    }
# 5436 "/usr/include/c++/4.8.2/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);
 }
    }
# 5472 "/usr/include/c++/4.8.2/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);
 }
    }
# 5514 "/usr/include/c++/4.8.2/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));
    }
# 5578 "/usr/include/c++/4.8.2/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));
    }
# 5638 "/usr/include/c++/4.8.2/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()));
    }
# 5680 "/usr/include/c++/4.8.2/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);
    }
# 5726 "/usr/include/c++/4.8.2/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));
    }
# 5793 "/usr/include/c++/4.8.2/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));
    }
# 5860 "/usr/include/c++/4.8.2/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;
    }
# 5917 "/usr/include/c++/4.8.2/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;
    }
# 5975 "/usr/include/c++/4.8.2/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);
    }
# 6036 "/usr/include/c++/4.8.2/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);
    }
# 6094 "/usr/include/c++/4.8.2/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));
    }
# 6160 "/usr/include/c++/4.8.2/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));
    }
# 6217 "/usr/include/c++/4.8.2/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;
    }
# 6245 "/usr/include/c++/4.8.2/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;
    }
# 6273 "/usr/include/c++/4.8.2/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;
    }
# 6301 "/usr/include/c++/4.8.2/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.2/algorithm" 2 3
# 38 "/opt/sevenflow/boost/include/boost/move/move.hpp" 2

# 1 "/usr/include/c++/4.8.2/iterator" 1 3
# 58 "/usr/include/c++/4.8.2/iterator" 3
       
# 59 "/usr/include/c++/4.8.2/iterator" 3





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

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





# 1 "/usr/include/c++/4.8.2/bits/ios_base.h" 1 3
# 37 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
       
# 38 "/usr/include/c++/4.8.2/bits/ios_base.h" 3



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





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

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


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






    string
    name() const;
# 225 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 730 "/usr/include/c++/4.8.2/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.2/bits/locale_classes.tcc" 1 3
# 37 "/usr/include/c++/4.8.2/bits/locale_classes.tcc" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/locale_classes.h" 2 3
# 42 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 436 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 448 "/usr/include/c++/4.8.2/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.2/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 577 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 594 "/usr/include/c++/4.8.2/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.2/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.2/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 683 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc) throw();
# 694 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
    locale
    getloc() const
    { return _M_ios_locale; }
# 705 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 724 "/usr/include/c++/4.8.2/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 740 "/usr/include/c++/4.8.2/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.2/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.2/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.2/ios" 2 3
# 1 "/usr/include/c++/4.8.2/streambuf" 1 3
# 36 "/usr/include/c++/4.8.2/streambuf" 3
       
# 37 "/usr/include/c++/4.8.2/streambuf" 3
# 45 "/usr/include/c++/4.8.2/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.2/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.2/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.2/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 238 "/usr/include/c++/4.8.2/streambuf" 3
      basic_streambuf*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }
# 250 "/usr/include/c++/4.8.2/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.2/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.2/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 297 "/usr/include/c++/4.8.2/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.2/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.2/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.2/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 371 "/usr/include/c++/4.8.2/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.2/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.2/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.2/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 463 "/usr/include/c++/4.8.2/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.2/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.2/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 508 "/usr/include/c++/4.8.2/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.2/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.2/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 554 "/usr/include/c++/4.8.2/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.2/streambuf" 3
      virtual void
      imbue(const locale& __loc)
      { }
# 590 "/usr/include/c++/4.8.2/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 601 "/usr/include/c++/4.8.2/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.2/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.2/streambuf" 3
      virtual int
      sync() { return 0; }
# 648 "/usr/include/c++/4.8.2/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 664 "/usr/include/c++/4.8.2/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 686 "/usr/include/c++/4.8.2/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 699 "/usr/include/c++/4.8.2/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.2/streambuf" 3
      virtual int_type
      pbackfail(int_type __c = traits_type::eof())
      { return traits_type::eof(); }
# 741 "/usr/include/c++/4.8.2/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 767 "/usr/include/c++/4.8.2/streambuf" 3
      virtual int_type
      overflow(int_type __c = traits_type::eof())
      { return traits_type::eof(); }



    public:
# 782 "/usr/include/c++/4.8.2/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.2/bits/streambuf.tcc" 1 3
# 37 "/usr/include/c++/4.8.2/bits/streambuf.tcc" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/streambuf" 2 3
# 44 "/usr/include/c++/4.8.2/ios" 2 3
# 1 "/usr/include/c++/4.8.2/bits/basic_ios.h" 1 3
# 33 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3
       
# 34 "/usr/include/c++/4.8.2/bits/basic_ios.h" 3



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

# 1 "/usr/include/c++/4.8.2/cwctype" 1 3
# 39 "/usr/include/c++/4.8.2/cwctype" 3
       
# 40 "/usr/include/c++/4.8.2/cwctype" 3
# 50 "/usr/include/c++/4.8.2/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.2/cwctype" 2 3
# 80 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 2 3
# 1 "/usr/include/c++/4.8.2/cctype" 1 3
# 39 "/usr/include/c++/4.8.2/cctype" 3
       
# 40 "/usr/include/c++/4.8.2/cctype" 3
# 41 "/usr/include/c++/4.8.2/bits/locale_facets.h" 2 3
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/ctype_base.h" 1 3
# 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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.2/bits/locale_facets.h" 2 3






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




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

# 49 "/usr/include/c++/4.8.2/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.2/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.2/bits/locale_facets.h" 2 3

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

# 64 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 239 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 268 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 304 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 389 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const = 0;
# 462 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const = 0;
# 495 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const = 0;
# 535 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const = 0;
# 581 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 723 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 751 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 765 "/usr/include/c++/4.8.2/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.2/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.2/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 811 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 844 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1021 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1054 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1097 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const
      { return __c; }
# 1149 "/usr/include/c++/4.8.2/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.2/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.2/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1218 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1261 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1331 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1364 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const;
# 1406 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const;
# 1455 "/usr/include/c++/4.8.2/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/c++/4.8.2/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
# 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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.2/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.2/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.2/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.2/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.2/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1719 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1750 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1763 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1776 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1793 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1805 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1818 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1831 "/usr/include/c++/4.8.2/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1844 "/usr/include/c++/4.8.2/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.2/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.2/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1961 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2253 "/usr/include/c++/4.8.2/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.2/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2292 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/locale_facets.tcc" 1 3
# 33 "/usr/include/c++/4.8.2/bits/locale_facets.tcc" 3
       
# 34 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/locale_facets.h" 2 3
# 38 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 141 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 250 "/usr/include/c++/4.8.2/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.2/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 300 "/usr/include/c++/4.8.2/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.2/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 354 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 423 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_ios.tcc" 1 3
# 33 "/usr/include/c++/4.8.2/bits/basic_ios.tcc" 3
       
# 34 "/usr/include/c++/4.8.2/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.2/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.2/bits/basic_ios.h" 2 3
# 45 "/usr/include/c++/4.8.2/ios" 2 3
# 39 "/usr/include/c++/4.8.2/ostream" 2 3


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

# 57 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/ostream" 3
      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }
# 269 "/usr/include/c++/4.8.2/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 302 "/usr/include/c++/4.8.2/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.2/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 347 "/usr/include/c++/4.8.2/ostream" 3
      __ostream_type&
      flush();
# 357 "/usr/include/c++/4.8.2/ostream" 3
      pos_type
      tellp();
# 368 "/usr/include/c++/4.8.2/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 380 "/usr/include/c++/4.8.2/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.2/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.2/ostream" 3
      explicit
      sentry(basic_ostream<_CharT, _Traits>& __os);
# 428 "/usr/include/c++/4.8.2/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.2/ostream" 3
      operator bool() const
      { return _M_ok; }
    };
# 469 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/ostream" 3

}

# 1 "/usr/include/c++/4.8.2/bits/ostream.tcc" 1 3
# 37 "/usr/include/c++/4.8.2/bits/ostream.tcc" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/ostream" 2 3
# 65 "/usr/include/c++/4.8.2/iterator" 2 3
# 1 "/usr/include/c++/4.8.2/istream" 1 3
# 36 "/usr/include/c++/4.8.2/istream" 3
       
# 37 "/usr/include/c++/4.8.2/istream" 3




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

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

      __istream_type&
      ignore(streamsize __n);

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

}

# 1 "/usr/include/c++/4.8.2/bits/istream.tcc" 1 3
# 37 "/usr/include/c++/4.8.2/bits/istream.tcc" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/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.2/istream" 2 3
# 66 "/usr/include/c++/4.8.2/iterator" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 1 3
# 33 "/usr/include/c++/4.8.2/bits/stream_iterator.h" 3
       
# 34 "/usr/include/c++/4.8.2/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.2/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.2/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.2/iterator" 2 3
# 40 "/opt/sevenflow/boost/include/boost/move/move.hpp" 2
# 67 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   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 has_trivial_destructor
      : public integral_constant<bool, false>
   {};


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

   }
   }
# 226 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   namespace boost {

   namespace move_detail {
      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>
   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__));
# 269 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   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>
   {};

   template <class T>
   struct has_move_emulation_enabled_aux
     : has_move_emulation_enabled<T> {};

   template <class T>
   struct has_nothrow_move
      : public ::boost::move_detail::integral_constant<bool, false>
   {};







   template <class T>
   inline typename ::boost::move_detail::disable_if<has_move_emulation_enabled_aux<T>, T&>::type move(T& x)
   {
      return x;
   }

   template <class T>
   inline typename ::boost::move_detail::enable_if<has_move_emulation_enabled<T>, 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<has_move_emulation_enabled<T>, rv<T>&>::type move(rv<T>& x)
   {
      return x;
   }
# 397 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   template <class T>
   inline typename ::boost::move_detail::enable_if< ::boost::move_detail::is_rv<T>, 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::disable_if< ::boost::move_detail::is_rv<T>, const T &>::type
      forward(const typename ::boost::move_detail::identity<T>::type &x)
   {
      return x;
   }
# 455 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   }
# 650 "/opt/sevenflow/boost/include/boost/move/move.hpp"
namespace boost {
# 663 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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>
{
};

}
# 795 "/opt/sevenflow/boost/include/boost/move/move.hpp"
template<class It>
inline move_iterator<It> make_move_iterator(const It &it)
{ return move_iterator<It>(it); }
# 808 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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);
}
# 848 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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);
}
# 941 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   template <typename I,
            typename O>
   O move(I f, I l, O result)
   {
      while (f != l) {
         *result = ::boost::move(*f);
         ++f; ++result;
      }
      return result;
   }
# 968 "/opt/sevenflow/boost/include/boost/move/move.hpp"
   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;
   }
# 995 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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;
   while (f != l) {
      ::new(static_cast<void*>(&*r)) input_value_type(boost::move(*f));
      ++f; ++r;
   }
   return r;
}
# 1030 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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);
}
# 1051 "/opt/sevenflow/boost/include/boost/move/move.hpp"
}

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);
}
# 1090 "/opt/sevenflow/boost/include/boost/move/move.hpp"
}

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);
}
# 1115 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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);
}
# 1138 "/opt/sevenflow/boost/include/boost/move/move.hpp"
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);
}
# 1159 "/opt/sevenflow/boost/include/boost/move/move.hpp"
template <class T>
struct has_trivial_destructor_after_move
   : ::boost::move_detail::has_trivial_destructor<T>
{};



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

}
# 1258 "/opt/sevenflow/boost/include/boost/move/move.hpp"
}
# 26 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/config.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/type_traits/config.hpp"
# 1 "/opt/sevenflow/boost/include/boost/detail/workaround.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/config.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/intrinsics.hpp" 1
# 190 "/opt/sevenflow/boost/include/boost/type_traits/intrinsics.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_same.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/type_traits/is_same.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 10 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/int.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/int.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/int_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/int_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/adl_barrier.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/adl_barrier.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/adl.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/adl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/msvc.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/intel.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/gcc.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/adl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/workaround.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/adl.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/adl_barrier.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/mpl/aux_/adl_barrier.hpp"
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/int_fwd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/nttp_decl.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/nttp_decl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/nttp.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/nttp_decl.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/mpl/int_fwd.hpp" 2

namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/opt/sevenflow/boost/include/boost/mpl/int.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/integral_c_tag.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/integral_c_tag.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/static_constant.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/integral_c_tag.hpp" 2

namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/static_cast.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/preprocessor/cat.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/cat.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/config/config.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/cat.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
    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 "/opt/sevenflow/boost/include/boost/mpl/int.hpp" 2
# 11 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/template_arity_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/template_arity_fwd.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 12 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/preprocessor.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2
# 45 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/comma_if.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/preprocessor/comma_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/comma_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/if.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/control/if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/iif.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/control/if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/logical/bool.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/control/if.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/facilities/empty.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/comma.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/comma_if.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/comma_if.hpp" 2
# 46 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repeat.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/preprocessor/repeat.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/debug/error.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/eat.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/repeat.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/inc.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/preprocessor/inc.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/inc.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/inc.hpp" 2
# 48 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/params.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/lambda.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/lambda.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/ttp.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/lambda.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/ctps.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/lambda.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/overload_resolution.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/integral_constant.hpp" 1
# 10 "/opt/sevenflow/boost/include/boost/type_traits/integral_constant.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/bool.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/bool.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/bool_fwd.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/bool_fwd.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/bool.hpp" 2



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;


}
# 11 "/opt/sevenflow/boost/include/boost/type_traits/integral_constant.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/integral_c.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/integral_c.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/integral_c_fwd.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/integral_c_fwd.hpp"
namespace mpl_ {





template< typename T, T N > struct integral_c;


}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
# 18 "/opt/sevenflow/boost/include/boost/mpl/integral_c.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/mpl/integral_c.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1
# 40 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
    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 "/opt/sevenflow/boost/include/boost/mpl/integral_c.hpp" 2




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 "/opt/sevenflow/boost/include/boost/type_traits/integral_constant.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/lambda_support.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/type_traits/is_same.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_same.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 101 "/opt/sevenflow/boost/include/boost/type_traits/is_same.hpp" 2
# 191 "/opt/sevenflow/boost/include/boost/type_traits/intrinsics.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_lvalue_reference.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/type_traits/is_lvalue_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/type_traits/is_lvalue_reference.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_lvalue_reference.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 116 "/opt/sevenflow/boost/include/boost/type_traits/is_lvalue_reference.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_rvalue_reference.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_rvalue_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/is_rvalue_reference.hpp" 2

namespace boost {

template< typename T > struct is_rvalue_reference : public ::boost::integral_constant<bool,false> { public: };




}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/type_traits/is_rvalue_reference.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/yes_no_type.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/yes_no_type.hpp"
namespace boost {
namespace type_traits {

typedef char yes_type;
struct no_type
{
   char padding[8];
};

}
}
# 15 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_or.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_or.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_and.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_and.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_not.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_not.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_eq.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/detail/ice_eq.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/ice.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/is_reference.hpp" 2
# 192 "/opt/sevenflow/boost/include/boost/type_traits/intrinsics.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/cv_traits_impl.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/cv_traits_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/cv_traits_impl.hpp"
}
}
# 29 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp"
}






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 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 151 "/opt/sevenflow/boost/include/boost/type_traits/is_volatile.hpp" 2
# 193 "/opt/sevenflow/boost/include/boost/type_traits/intrinsics.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_void.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_void.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/is_void.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/type_traits/is_void.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_arithmetic.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_arithmetic.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_integral.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_integral.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/is_integral.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_integral.hpp"
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: };







}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 77 "/opt/sevenflow/boost/include/boost/type_traits/is_integral.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/is_arithmetic.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_float.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_float.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/is_float.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/type_traits/is_float.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_arithmetic.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/type_traits/is_arithmetic.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/type_traits/is_arithmetic.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_enum.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/type_traits/is_enum.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/type_traits/is_enum.hpp" 2

namespace boost {
# 181 "/opt/sevenflow/boost/include/boost/type_traits/is_enum.hpp"
template< typename T > struct is_enum : public ::boost::integral_constant<bool,__is_enum(T)> { public: };



}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 188 "/opt/sevenflow/boost/include/boost/type_traits/is_enum.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
}
}
# 25 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/broken_compiler_spec.hpp" 1
# 95 "/opt/sevenflow/boost/include/boost/type_traits/broken_compiler_spec.hpp"















# 15 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp" 2




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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp"
}



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 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 83 "/opt/sevenflow/boost/include/boost/type_traits/remove_cv.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 135 "/opt/sevenflow/boost/include/boost/type_traits/is_member_function_pointer.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp" 2
# 39 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp" 2

namespace boost {
# 50 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 115 "/opt/sevenflow/boost/include/boost/type_traits/is_member_pointer.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp" 2

namespace boost {





namespace detail {

template< typename T > struct is_pointer_helper
{
    static const bool value = false;
};
# 63 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp"
template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };



template< typename T >
struct is_pointer_impl
{
# 80 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp"
    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 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 161 "/opt/sevenflow/boost/include/boost/type_traits/is_pointer.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 54 "/opt/sevenflow/boost/include/boost/type_traits/is_scalar.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp" 2



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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 19 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp" 2







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 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 140 "/opt/sevenflow/boost/include/boost/type_traits/is_pod.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 48 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_destructor.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/min_max.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/interprocess/detail/min_max.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/min_max.hpp" 2


namespace boost {
namespace interprocess {

template<class T>
const T &max_value(const T &a, const T &b)
{ return a > b ? a : b; }

template<class T>
const T &min_value(const T &a, const T &b)
{ return a < b ? a : b; }

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/interprocess/detail/min_max.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/type_traits.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/interprocess/detail/type_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/type_traits.hpp" 2

namespace boost {
namespace interprocess {
namespace ipcdetail {

struct nat{};

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

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

template<class T>
struct is_reference
{
   static const bool value = false;
};

template<class T>
struct is_reference<T&>
{
   static const bool value = true;
};

template<class T>
struct is_pointer
{
   static const bool value = false;
};

template<class T>
struct is_pointer<T*>
{
   static const bool value = true;
};

template <typename T>
struct add_reference
{
    typedef T& type;
};

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

template<>
struct add_reference<void>
{
    typedef nat &type;
};

template<>
struct add_reference<const void>
{
    typedef const nat &type;
};

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

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

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

template<class T>
struct remove_const<const T>
{
   typedef T type;
};

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

template<class T>
struct remove_volatile<volatile T>
{
   typedef T type;
};

template <typename T, typename U>
struct is_same
{
   typedef char yes_type;
   struct no_type
   {
      char padding[8];
   };

   template <typename V>
   static yes_type is_same_tester(V*, V*);
   static no_type is_same_tester(...);

   static T *t;
   static U *u;

   static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u));
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 144 "/opt/sevenflow/boost/include/boost/interprocess/detail/type_traits.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/transform_iterator.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/transform_iterator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/interprocess/detail/transform_iterator.hpp" 2







namespace boost {
namespace interprocess {

template <class PseudoReference>
struct operator_arrow_proxy
{
   operator_arrow_proxy(const PseudoReference &px)
      : m_value(px)
   {}

   PseudoReference* operator->() const { return &m_value; }



   mutable PseudoReference m_value;
};

template <class T>
struct operator_arrow_proxy<T&>
{
   operator_arrow_proxy(T &px)
      : m_value(px)
   {}

   T* operator->() const { return const_cast<T*>(&m_value); }



   T &m_value;
};

template <class Iterator, class UnaryFunction>
class transform_iterator
   : public UnaryFunction
   , public std::iterator
      < typename Iterator::iterator_category
      , typename ipcdetail::remove_reference<typename UnaryFunction::result_type>::type
      , typename Iterator::difference_type
      , operator_arrow_proxy<typename UnaryFunction::result_type>
      , typename UnaryFunction::result_type>
{
   public:
   explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
      : UnaryFunction(f), m_it(it)
   {}

   explicit transform_iterator()
      : UnaryFunction(), m_it()
   {}


   transform_iterator& operator++()
   { increment(); return *this; }

   transform_iterator operator++(int)
   {
      transform_iterator result (*this);
      increment();
      return result;
   }

   transform_iterator& operator--()
   { decrement(); return *this; }

   transform_iterator operator--(int)
   {
      transform_iterator result (*this);
      decrement();
      return result;
   }

   friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
   { return i.equal(i2); }

   friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
   { return !(i == i2); }

   friend bool operator< (const transform_iterator& i, const transform_iterator& i2)
   { return i < i2; }

   friend bool operator> (const transform_iterator& i, const transform_iterator& i2)
   { return i2 < i; }

   friend bool operator<= (const transform_iterator& i, const transform_iterator& i2)
   { return !(i > i2); }

   friend bool operator>= (const transform_iterator& i, const transform_iterator& i2)
   { return !(i < i2); }

   friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
   { return i2.distance_to(i); }


   transform_iterator& operator+=(typename Iterator::difference_type off)
   { this->advance(off); return *this; }

   transform_iterator operator+(typename Iterator::difference_type off) const
   {
      transform_iterator other(*this);
      other.advance(off);
      return other;
   }

   friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
   { return right + off; }

   transform_iterator& operator-=(typename Iterator::difference_type off)
   { this->advance(-off); return *this; }

   transform_iterator operator-(typename Iterator::difference_type off) const
   { return *this + (-off); }

   typename UnaryFunction::result_type operator*() const
   { return dereference(); }

   typename UnaryFunction::result_type operator[](typename Iterator::difference_type off) const
   { return UnaryFunction::operator()(m_it[off]); }

   operator_arrow_proxy<typename UnaryFunction::result_type>
      operator->() const
   { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference()); }

   Iterator & base()
   { return m_it; }

   const Iterator & base() const
   { return m_it; }

   private:
   Iterator m_it;

   void increment()
   { ++m_it; }

   void decrement()
   { --m_it; }

   bool equal(const transform_iterator &other) const
   { return m_it == other.m_it; }

   bool less(const transform_iterator &other) const
   { return other.m_it < m_it; }

   typename UnaryFunction::result_type dereference() const
   { return UnaryFunction::operator()(*m_it); }

   void advance(typename Iterator::difference_type n)
   { std::advance(m_it, n); }

   typename Iterator::difference_type distance_to(const transform_iterator &other)const
   { return std::distance(other.m_it, m_it); }
};

template <class Iterator, class UnaryFunc>
transform_iterator<Iterator, UnaryFunc>
make_transform_iterator(Iterator it, UnaryFunc fun)
{
   return transform_iterator<Iterator, UnaryFunc>(it, fun);
}

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 193 "/opt/sevenflow/boost/include/boost/interprocess/detail/transform_iterator.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/mpl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/interprocess/detail/mpl.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/mpl.hpp" 2

namespace boost {
namespace interprocess {
namespace ipcdetail {

template <class T, T val>
struct integral_constant
{
   static const T value = val;
   typedef integral_constant<T,val> type;
};

template< bool C_ >
struct bool_ : integral_constant<bool, C_>
{
   static const bool value = C_;
};

typedef bool_<true> true_;
typedef bool_<false> false_;

typedef true_ true_type;
typedef false_ false_type;

typedef char yes_type;
struct no_type
{
   char padding[8];
};

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, 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:
   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
};

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 <class Pair>
struct select1st

{
   template<class OtherPair>
   const typename Pair::first_type& operator()(const OtherPair& x) const
   { return x.first; }

   const typename Pair::first_type& operator()(const typename Pair::first_type& x) const
   { return x; }
};


template <class T>
struct identity

{
   typedef T type;
   const T& operator()(const T& x) const
   { return x; }
};

template<std::size_t S>
struct ls_zeros
{
   static const std::size_t value = (S & std::size_t(1)) ? 0 : (1u + ls_zeros<(S >> 1u)>::value);
};

template<>
struct ls_zeros<0>
{
   static const std::size_t value = 0;
};

template<>
struct ls_zeros<1>
{
   static const std::size_t value = 0;
};

}
}
}
# 31 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/containers/version_type.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/containers/version_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/containers/version_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/detail/version_type.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/container/detail/version_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/container/detail/version_type.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/container/detail/mpl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/container/detail/mpl.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/container/detail/mpl.hpp" 2

namespace boost {
namespace container {
namespace container_detail {

template <class T, T val>
struct integral_constant
{
   static const T value = val;
   typedef integral_constant<T,val> type;
};

template< bool C_ >
struct bool_ : integral_constant<bool, C_>
{
   static const bool value = C_;
   operator bool() const { return bool_::value; }
};

typedef bool_<true> true_;
typedef bool_<false> false_;

typedef true_ true_type;
typedef false_ false_type;

typedef char yes_type;
struct no_type
{
   char padding[8];
};

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 <bool B, class T = void>
struct disable_if_c : public enable_if_c<!B, T> {};

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<
      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 <class Pair>
struct select1st

{
   template<class OtherPair>
   const typename Pair::first_type& operator()(const OtherPair& x) const
   { return x.first; }

   const typename Pair::first_type& operator()(const typename Pair::first_type& x) const
   { return x; }
};


template <class T>
struct identity

{
   typedef T type;
   const T& operator()(const T& x) const
   { return x; }
};

template<std::size_t S>
struct ls_zeros
{
   static const std::size_t value = (S & std::size_t(1)) ? 0 : (1u + ls_zeros<(S >> 1u)>::value);
};

template<>
struct ls_zeros<0>
{
   static const std::size_t value = 0;
};

template<>
struct ls_zeros<1>
{
   static const std::size_t value = 0;
};

template <typename T> struct unvoid { typedef T type; };
template <> struct unvoid<void> { struct type { }; };
template <> struct unvoid<const void> { struct type { }; };

}
}
}
# 22 "/opt/sevenflow/boost/include/boost/container/detail/version_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/detail/type_traits.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/container/detail/type_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/container/detail/type_traits.hpp" 2



namespace boost {
namespace container {
namespace container_detail {

struct nat{};

template <typename U>
struct LowPriorityConversion
{

   LowPriorityConversion(const U&) { }
};



template <typename T> struct alignment_of;

template <typename T>
struct alignment_of_hack
{
    char c;
    T t;
    alignment_of_hack();
};

template <unsigned A, unsigned S>
struct alignment_logic
{
    enum{ value = A < S ? A : S };
};

template< typename T >
struct alignment_of
{
   enum{ value = alignment_logic
            < sizeof(alignment_of_hack<T>) - sizeof(T)
            , sizeof(T)>::value };
};


union max_align
{
   char char_;
   short short_;
   int int_;
   long long_;

   long long long_long_;

   float float_;
   double double_;
   long double long_double_;
   void * void_ptr_;
};

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

template<class T>
struct remove_reference<T&>
{
   typedef T type;
};
# 103 "/opt/sevenflow/boost/include/boost/container/detail/type_traits.hpp"
template<class T>
struct remove_reference< ::boost::rv<T> >
{
   typedef T type;
};



template<class T>
struct is_reference
{
   enum { value = false };
};

template<class T>
struct is_reference<T&>
{
   enum { value = true };
};

template<class T>
struct is_pointer
{
   enum { value = false };
};

template<class T>
struct is_pointer<T*>
{
   enum { value = true };
};

template <typename T>
struct add_reference
{
    typedef T& type;
};

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

template<>
struct add_reference<void>
{
    typedef nat &type;
};

template<>
struct add_reference<const void>
{
    typedef const nat &type;
};

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

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

template <typename T, typename U>
struct is_same
{
   typedef char yes_type;
   struct no_type
   {
      char padding[8];
   };

   template <typename V>
   static yes_type is_same_tester(V*, V*);
   static no_type is_same_tester(...);

   static T *t;
   static U *u;

   static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u));
};

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

template<class T>
struct remove_const< const T>
{
   typedef T type;
};

template<class T>
struct remove_ref_const
{
   typedef typename remove_const< typename remove_reference<T>::type >::type type;
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 209 "/opt/sevenflow/boost/include/boost/container/detail/type_traits.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/container/detail/version_type.hpp" 2

namespace boost{
namespace container {
namespace container_detail {



template <class T, unsigned V>
struct version_type
    : public container_detail::integral_constant<unsigned, V>
{
    typedef T type;

    version_type(const version_type<T, 0>&);
};

namespace impl{

template <class T,
          bool = container_detail::is_convertible<version_type<T, 0>, typename T::version>::value>
struct extract_version
{
   static const unsigned value = 1;
};

template <class T>
struct extract_version<T, true>
{
   static const unsigned value = T::version::value;
};

template <class T>
struct has_version
{
   private:
   struct two {char _[2];};
   template <class U> static two test(...);
   template <class U> static char test(const typename U::version*);
   public:
   static const bool value = sizeof(test<T>(0)) == 1;
   void dummy(){}
};

template <class T, bool = has_version<T>::value>
struct version
{
   static const unsigned value = 1;
};

template <class T>
struct version<T, true>
{
   static const unsigned value = extract_version<T>::value;
};

}

template <class T>
struct version
   : public container_detail::integral_constant<unsigned, impl::version<T>::value>
{
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 91 "/opt/sevenflow/boost/include/boost/container/detail/version_type.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/interprocess/containers/version_type.hpp" 2

namespace boost {
namespace interprocess {

using boost::container::container_detail::version_type;
using boost::container::container_detail::version;

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/interprocess/containers/version_type.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/workaround.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/intrusive/detail/workaround.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/intrusive/detail/workaround.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/intrusive/detail/workaround.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 18 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp" 2

namespace boost {
namespace intrusive {
namespace detail {

typedef char one;
struct two {one _[2];};

template< bool C_ >
struct bool_
{
   static const bool value = C_;
};

typedef bool_<true> true_;
typedef bool_<false> false_;

typedef true_ true_type;
typedef false_ false_type;

typedef char yes_type;
struct no_type
{
   char padding[8];
};

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 F, class Param>
struct apply
{
   typedef typename F::template apply<Param>::type 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 const T &trigger();
   public:
   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
};

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 C
    , typename T1
    , typename T2
    >
struct if_
{
   typedef typename if_c<0 != C::value, T1, T2>::type type;
};

template<
      bool C
    , typename F1
    , typename F2
    >
struct eval_if_c
    : if_c<C,F1,F2>::type
{};

template<
      typename C
    , typename T1
    , typename T2
    >
struct eval_if
    : if_<C,T1,T2>::type
{};


template <class T>
struct identity
{
   typedef T type;
};
# 137 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp"
template <typename T>
struct is_unary_or_binary_function_impl
{ static const bool value = false; };





template <typename R>
struct is_unary_or_binary_function_impl<R (*)()>
{ static const bool value = true; };

template <typename R>
struct is_unary_or_binary_function_impl<R (*)(...)>
{ static const bool value = true; };
# 181 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp"
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0)>
{ static const bool value = true; };

template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0...)>
{ static const bool value = true; };
# 217 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp"
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
{ static const bool value = true; };

template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
{ static const bool value = true; };
# 248 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp"
template <typename T>
struct is_unary_or_binary_function_impl<T&>
{ static const bool value = false; };

template<typename T>
struct is_unary_or_binary_function
{ static const bool value = is_unary_or_binary_function_impl<T>::value; };



template <typename T> struct alignment_of;

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
{
   static const std::size_t value = alignment_logic
            < sizeof(alignment_of_hack<T>) - sizeof(T)
            , sizeof(T)
            >::value;
};

template <typename T, typename U>
struct is_same
{
   typedef char yes_type;
   struct no_type
   {
      char padding[8];
   };

   template <typename V>
   static yes_type is_same_tester(V*, V*);
   static no_type is_same_tester(...);

   static T *t;
   static U *u;

   static const bool value = sizeof(yes_type) == sizeof(is_same_tester(t,u));
};

template<typename T>
struct add_const
{ typedef const T type; };

template<typename T>
struct remove_const
{ typedef T type; };

template<typename T>
struct remove_const<const T>
{ typedef T type; };

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

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

template<class Class>
class is_empty_class
{
   template <typename T>
   struct empty_helper_t1 : public T
   {
      empty_helper_t1();
      int i[256];
   };

   struct empty_helper_t2
   { int i[256]; };

   public:
   static const bool value = sizeof(empty_helper_t1<Class>) == sizeof(empty_helper_t2);
};

template<std::size_t S>
struct ls_zeros
{
   static const std::size_t value = (S & std::size_t(1)) ? 0 : (1 + ls_zeros<(S>>1u)>::value);
};

template<>
struct ls_zeros<0>
{
   static const std::size_t value = 0;
};

template<>
struct ls_zeros<1>
{
   static const std::size_t value = 0;
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 366 "/opt/sevenflow/boost/include/boost/intrusive/detail/mpl.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/local.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/local.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/slot.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/slot/slot.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/def.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/slot/slot.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/local.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/elem.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/elem.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/facilities/overload.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/facilities/overload.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/variadic/size.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/facilities/overload.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/elem.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/rem.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/elem.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/variadic/elem.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/elem.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/local.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/paren_if.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/paren_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/paren.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/punctuation/paren_if.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/expr_if.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/control/expr_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/expr_iif.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/control/expr_if.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_params.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1
# 29 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_trailing.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_trailing.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_trailing.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_shifted_params.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_shifted_params.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/dec.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_shifted_params.hpp" 2
# 31 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_shifted.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_shifted.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_shifted.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/logical/not.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/logical/not.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/logical/compl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/logical/not.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/sub.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/sub.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_left.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_left.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_left.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_left.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_left.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/detail/fold_left.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/list/detail/fold_left.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/adt.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/list/adt.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/is_binary.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/detail/is_binary.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/check.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/detail/is_binary.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/list/adt.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/list/detail/fold_left.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_left.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_right.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_right.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_right.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_right.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/detail/fold_right.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/list/detail/fold_right.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/reverse.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/list/detail/fold_right.hpp" 2
# 38 "/opt/sevenflow/boost/include/boost/preprocessor/list/fold_right.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/logical/bitand.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 2
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/detail/while.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/preprocessor/control/while.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/sub.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/add.hpp" 1
# 36 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/iterate.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/iterate.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/array/elem.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/preprocessor/array/elem.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/array/data.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/array/elem.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/array/size.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/array/elem.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/iterate.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 50 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 51 "/opt/sevenflow/boost/include/boost/intrusive/detail/preprocessor.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2

namespace boost {
namespace intrusive {
namespace detail {

template <typename T>
inline T* addressof(T& obj)
{
   return static_cast<T*>
      (static_cast<void*>
         (const_cast<char*>
            (&reinterpret_cast<const char&>(obj))
         )
      );
}

template <typename T> struct unvoid { typedef T type; };
template <> struct unvoid<void> { struct type { }; };
template <> struct unvoid<const void> { struct type { }; };

template <typename T>
struct LowPriorityConversion
{

    LowPriorityConversion(const T&) { }
};
# 110 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp"
}}}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/static_assert.hpp" 1
# 51 "/opt/sevenflow/boost/include/boost/static_assert.hpp"
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{};

}
# 22 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost_intrusive_has_member_function_callable_with {

      struct dont_care
      {
         dont_care(...);
      };

      struct private_type
      {
         static private_type p;
         private_type const &operator,(int) const;
      };

      typedef char yes_type;
      struct no_type{ char dummy[2]; };

      template<typename T>
      no_type is_private_type(T const &);
      yes_type is_private_type(private_type const &);

      }

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 55 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 2
# 113 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace intrusive { namespace detail {

      template <typename Type>
      class has_member_function_named_pointer_to
      {
         struct BaseMixin
         {
            void pointer_to();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::pointer_to>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void>
         struct has_member_function_callable_with_pointer_to_impl;


         template<typename Fun , class P0>
         struct has_member_function_callable_with_pointer_to_impl
            <Fun, false , P0>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           pointer_to (), 0))>
            struct zeroarg_checker_pointer_to
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_pointer_to(int);
            };



            template<class F>
            struct zeroarg_checker_pointer_to<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_pointer_to(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_pointer_to_impl
               <Fun, true , void>
            {
               template<class U>
               static zeroarg_checker_pointer_to<U>
                  Test(zeroarg_checker_pointer_to<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun>
         struct funwrap1_pointer_to

            : Fun
         {
            funwrap1_pointer_to
                                                                                                      ();

            using Fun::pointer_to;
            boost_intrusive_has_member_function_callable_with::private_type
               pointer_to
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_pointer_to_impl

            <Fun, true
            , P0
           

                                         >
         {
            typedef funwrap1_pointer_to
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              pointer_to
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun
                  , class P0 = void>
         struct has_member_function_callable_with_pointer_to
            : public has_member_function_callable_with_pointer_to_impl
               <Fun, has_member_function_named_pointer_to<Fun>::value
               , P0 >
         {};

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 119 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace intrusive { namespace detail {

      template <typename Type>
      class has_member_function_named_static_cast_from
      {
         struct BaseMixin
         {
            void static_cast_from();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::static_cast_from>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void>
         struct has_member_function_callable_with_static_cast_from_impl;


         template<typename Fun , class P0>
         struct has_member_function_callable_with_static_cast_from_impl
            <Fun, false , P0>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           static_cast_from (), 0))>
            struct zeroarg_checker_static_cast_from
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_static_cast_from(int);
            };



            template<class F>
            struct zeroarg_checker_static_cast_from<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_static_cast_from(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_static_cast_from_impl
               <Fun, true , void>
            {
               template<class U>
               static zeroarg_checker_static_cast_from<U>
                  Test(zeroarg_checker_static_cast_from<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun>
         struct funwrap1_static_cast_from

            : Fun
         {
            funwrap1_static_cast_from
                                                                                                      ();

            using Fun::static_cast_from;
            boost_intrusive_has_member_function_callable_with::private_type
               static_cast_from
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_static_cast_from_impl

            <Fun, true
            , P0
           

                                         >
         {
            typedef funwrap1_static_cast_from
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              static_cast_from
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun
                  , class P0 = void>
         struct has_member_function_callable_with_static_cast_from
            : public has_member_function_callable_with_static_cast_from_impl
               <Fun, has_member_function_named_static_cast_from<Fun>::value
               , P0 >
         {};

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 125 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace intrusive { namespace detail {

      template <typename Type>
      class has_member_function_named_const_cast_from
      {
         struct BaseMixin
         {
            void const_cast_from();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::const_cast_from>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void>
         struct has_member_function_callable_with_const_cast_from_impl;


         template<typename Fun , class P0>
         struct has_member_function_callable_with_const_cast_from_impl
            <Fun, false , P0>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           const_cast_from (), 0))>
            struct zeroarg_checker_const_cast_from
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_const_cast_from(int);
            };



            template<class F>
            struct zeroarg_checker_const_cast_from<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_const_cast_from(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_const_cast_from_impl
               <Fun, true , void>
            {
               template<class U>
               static zeroarg_checker_const_cast_from<U>
                  Test(zeroarg_checker_const_cast_from<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun>
         struct funwrap1_const_cast_from

            : Fun
         {
            funwrap1_const_cast_from
                                                                                                      ();

            using Fun::const_cast_from;
            boost_intrusive_has_member_function_callable_with::private_type
               const_cast_from
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_const_cast_from_impl

            <Fun, true
            , P0
           

                                         >
         {
            typedef funwrap1_const_cast_from
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              const_cast_from
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun
                  , class P0 = void>
         struct has_member_function_callable_with_const_cast_from
            : public has_member_function_callable_with_const_cast_from_impl
               <Fun, has_member_function_named_const_cast_from<Fun>::value
               , P0 >
         {};

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 131 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace intrusive { namespace detail {

      template <typename Type>
      class has_member_function_named_dynamic_cast_from
      {
         struct BaseMixin
         {
            void dynamic_cast_from();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::dynamic_cast_from>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void>
         struct has_member_function_callable_with_dynamic_cast_from_impl;


         template<typename Fun , class P0>
         struct has_member_function_callable_with_dynamic_cast_from_impl
            <Fun, false , P0>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           dynamic_cast_from (), 0))>
            struct zeroarg_checker_dynamic_cast_from
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_dynamic_cast_from(int);
            };



            template<class F>
            struct zeroarg_checker_dynamic_cast_from<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_dynamic_cast_from(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_dynamic_cast_from_impl
               <Fun, true , void>
            {
               template<class U>
               static zeroarg_checker_dynamic_cast_from<U>
                  Test(zeroarg_checker_dynamic_cast_from<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun>
         struct funwrap1_dynamic_cast_from

            : Fun
         {
            funwrap1_dynamic_cast_from
                                                                                                      ();

            using Fun::dynamic_cast_from;
            boost_intrusive_has_member_function_callable_with::private_type
               dynamic_cast_from
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_dynamic_cast_from_impl

            <Fun, true
            , P0
           

                                         >
         {
            typedef funwrap1_dynamic_cast_from
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              dynamic_cast_from
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace intrusive { namespace detail {

         template<typename Fun
                  , class P0 = void>
         struct has_member_function_callable_with_dynamic_cast_from
            : public has_member_function_callable_with_dynamic_cast_from_impl
               <Fun, has_member_function_named_dynamic_cast_from<Fun>::value
               , P0 >
         {};

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 137 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2

namespace boost {
namespace intrusive {
namespace detail {

template <typename T, typename DefaultType> struct boost_intrusive_default_type_element_type { template <typename X> static char test(int, typename X::element_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType element_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::element_type type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_element_type { template <typename X> static char test(int, typename X::element_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type element_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::element_type type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_difference_type { template <typename X> static char test(int, typename X::difference_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType difference_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::difference_type type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_difference_type { template <typename X> static char test(int, typename X::difference_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type difference_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::difference_type type; };





template <typename T> struct first_param
{ typedef void type; };
# 174 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        template < template <typename > class TemplateClass , typename T > struct first_param < TemplateClass<T > > { typedef T type; };


        template < template <typename , typename > class TemplateClass , typename T , class P0> struct first_param < TemplateClass<T , P0> > { typedef T type; };


        template < template <typename , typename , typename > class TemplateClass , typename T , class P0 , class P1> struct first_param < TemplateClass<T , P0 , P1> > { typedef T type; };


        template < template <typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2> struct first_param < TemplateClass<T , P0 , P1 , P2> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3 , class P4> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3 , P4> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3 , P4 , P5> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3 , P4 , P5 , P6> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8> > { typedef T type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename , typename , typename , typename > class TemplateClass , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9> struct first_param < TemplateClass<T , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9> > { typedef T type; };
# 175 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2






template <typename Ptr, typename T>
struct type_has_rebind
{
   template <typename X>

   static char test(int, typename X::template rebind<T>*);




   template <typename X>
   static int test(boost::intrusive::detail::LowPriorityConversion<int>, void*);

   static const bool value = (1 == sizeof(test<Ptr>(0, 0)));
};

template <typename Ptr, typename T>
struct type_has_rebind_other
{
   template <typename X>

   static char test(int, typename X::template rebind<T>::other*);




   template <typename X>
   static int test(boost::intrusive::detail::LowPriorityConversion<int>, void*);

   static const bool value = (1 == sizeof(test<Ptr>(0, 0)));
};

template <typename Ptr, typename T>
struct type_rebind_mode
{
   static const unsigned int rebind = (unsigned int)type_has_rebind<Ptr, T>::value;
   static const unsigned int rebind_other = (unsigned int)type_has_rebind_other<Ptr, T>::value;
   static const unsigned int mode = rebind + rebind*rebind_other;
};




template <typename Ptr, typename U, unsigned int RebindMode = type_rebind_mode<Ptr, U>::mode>
struct type_rebinder;



template <typename Ptr, typename U>
struct type_rebinder< Ptr, U, 2u >
{
   typedef typename Ptr::template rebind<U>::other type;
};



template <typename Ptr, typename U>
struct type_rebinder< Ptr, U, 1u >
{
   typedef typename Ptr::template rebind<U> type;
};
# 278 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        template < template <typename > class Ptr , typename T , class U> struct type_rebinder < Ptr<T >, U, 0u > { typedef Ptr<U > type; };


        template < template <typename , typename > class Ptr , typename T , class P0 , class U> struct type_rebinder < Ptr<T , P0>, U, 0u > { typedef Ptr<U , P0> type; };


        template < template <typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class U> struct type_rebinder < Ptr<T , P0 , P1>, U, 0u > { typedef Ptr<U , P0 , P1> type; };


        template < template <typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2>, U, 0u > { typedef Ptr<U , P0 , P1 , P2> type; };


        template < template <typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3> type; };


        template < template <typename , typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3 , P4>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3 , P4> type; };


        template < template <typename , typename , typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3 , P4 , P5>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3 , P4 , P5> type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3 , P4 , P5 , P6>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3 , P4 , P5 , P6> type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7> type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8> type; };


        template < template <typename , typename , typename , typename , typename , typename , typename , typename , typename , typename , typename > class Ptr , typename T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class U> struct type_rebinder < Ptr<T , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9>, U, 0u > { typedef Ptr<U , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9> type; };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2



}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 287 "/opt/sevenflow/boost/include/boost/intrusive/detail/memory_util.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 29 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp" 2

namespace boost {
namespace intrusive {





template <typename Ptr>
struct pointer_traits
{
# 68 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp"
      typedef Ptr pointer;

      typedef typename boost::intrusive::detail:: boost_intrusive_eval_default_type_element_type< Ptr, boost::intrusive::detail::first_param<Ptr> >::type

                                                                              element_type;

      typedef typename boost::intrusive::detail:: boost_intrusive_default_type_difference_type< Ptr, std::ptrdiff_t >::type
                                                                              difference_type;

      typedef typename boost::intrusive::detail::unvoid<element_type>::type& reference;

      template <class U> struct rebind_pointer
      {
         typedef typename boost::intrusive::detail::type_rebinder<Ptr, U>::type type;
      };
# 94 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp"
   static pointer pointer_to(reference r)
   {


      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_pointer_to
            <Ptr, typename boost::intrusive::detail::unvoid<element_type &>::type>::value;
      ::boost::integral_constant<bool, value> flag;
      return pointer_traits::priv_pointer_to(flag, r);
   }





   template<class UPtr>
   static pointer static_cast_from(const UPtr &uptr)
   {
      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_static_cast_from
            <Ptr, const UPtr>::value;
      ::boost::integral_constant<bool, value> flag;
      return pointer_traits::priv_static_cast_from(flag, uptr);
   }





   template<class UPtr>
   static pointer const_cast_from(const UPtr &uptr)
   {
      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_const_cast_from
            <Ptr, const UPtr>::value;
      ::boost::integral_constant<bool, value> flag;
      return pointer_traits::priv_const_cast_from(flag, uptr);
   }





   template<class UPtr>
   static pointer dynamic_cast_from(const UPtr &uptr)
   {
      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_dynamic_cast_from
            <Ptr, const UPtr>::value;
      ::boost::integral_constant<bool, value> flag;
      return pointer_traits::priv_dynamic_cast_from(flag, uptr);
   }


   private:

   template <class T>
   static T* to_raw_pointer(T* p)
   { return p; }

   template <class Pointer>
   static typename pointer_traits<Pointer>::element_type*
      to_raw_pointer(const Pointer &p)
   { return pointer_traits::to_raw_pointer(p.operator->()); }


   static pointer priv_pointer_to(boost::true_type, typename boost::intrusive::detail::unvoid<element_type>::type& r)
      { return Ptr::pointer_to(r); }

   static pointer priv_pointer_to(boost::false_type, typename boost::intrusive::detail::unvoid<element_type>::type& r)
      { return pointer(boost::intrusive::detail::addressof(r)); }


   template<class UPtr>
   static pointer priv_static_cast_from(boost::true_type, const UPtr &uptr)
   { return Ptr::static_cast_from(uptr); }

   template<class UPtr>
   static pointer priv_static_cast_from(boost::false_type, const UPtr &uptr)
   { return pointer_to(static_cast<element_type&>(*uptr)); }


   template<class UPtr>
   static pointer priv_const_cast_from(boost::true_type, const UPtr &uptr)
   { return Ptr::const_cast_from(uptr); }

   template<class UPtr>
   static pointer priv_const_cast_from(boost::false_type, const UPtr &uptr)
   { return pointer_to(const_cast<element_type&>(*uptr)); }


   template<class UPtr>
   static pointer priv_dynamic_cast_from(boost::true_type, const UPtr &uptr)
   { return Ptr::dynamic_cast_from(uptr); }

   template<class UPtr>
   static pointer priv_dynamic_cast_from(boost::false_type, const UPtr &uptr)
   { return pointer_to(*dynamic_cast<element_type*>(&*uptr)); }

};




template <typename Ptr>
struct pointer_traits<const Ptr> : pointer_traits<Ptr> {};
template <typename Ptr>
struct pointer_traits<volatile Ptr> : pointer_traits<Ptr> { };
template <typename Ptr>
struct pointer_traits<const volatile Ptr> : pointer_traits<Ptr> { };

template <typename Ptr>
struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };





template <typename T>
struct pointer_traits<T*>
{
   typedef T element_type;
   typedef T* pointer;
   typedef std::ptrdiff_t difference_type;
# 227 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp"
      typedef typename boost::intrusive::detail::unvoid<element_type>::type& reference;





   template <class U> struct rebind_pointer
   { typedef U* type; };



   static pointer pointer_to(reference r)
   { return boost::intrusive::detail::addressof(r); }



   template<class U>
   static pointer static_cast_from(U *uptr)
   { return static_cast<pointer>(uptr); }



   template<class U>
   static pointer const_cast_from(U *uptr)
   { return const_cast<pointer>(uptr); }



   template<class U>
   static pointer dynamic_cast_from(U *uptr)
   { return dynamic_cast<pointer>(uptr); }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 264 "/opt/sevenflow/boost/include/boost/intrusive/pointer_traits.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2




namespace boost {
namespace interprocess {
namespace ipcdetail {

template <class T>
inline T* to_raw_pointer(T* p)
{ return p; }

template <class Pointer>
inline typename boost::intrusive::pointer_traits<Pointer>::element_type*
to_raw_pointer(const Pointer &p)
{ return boost::interprocess::ipcdetail::to_raw_pointer(p.operator->()); }


template <class T>
inline void do_swap(T& x, T& y)
{
   using std::swap;
   swap(x, y);
}


template<class SizeType>
inline SizeType get_rounded_size(SizeType orig_size, SizeType round_to)
{
   return ((orig_size-1)/round_to+1)*round_to;
}


template<class SizeType>
inline SizeType get_truncated_size(SizeType orig_size, SizeType multiple)
{
   return orig_size/multiple*multiple;
}


template<class SizeType>
inline SizeType get_rounded_size_po2(SizeType orig_size, SizeType round_to)
{
   return ((orig_size-1)&(~(round_to-1))) + round_to;
}


template<class SizeType>
inline SizeType get_truncated_size_po2(SizeType orig_size, SizeType multiple)
{
   return (orig_size & (~(multiple-1)));
}

template <std::size_t OrigSize, std::size_t RoundTo>
struct ct_rounded_size
{
   static const std::size_t value = ((OrigSize-1)/RoundTo+1)*RoundTo;
};


template <int p, int n = 4>
struct ct_max_pow2_less
{
   static const std::size_t c = 2*n < p;

   static const std::size_t value =
         c ? (ct_max_pow2_less< c*p, 2*c*n>::value) : n;
};

template <>
struct ct_max_pow2_less<0, 0>
{
   static const std::size_t value = 0;
};

}




template <class Index>
struct is_node_index
{
   static const bool value = false;
};





template <class Index>
struct is_intrusive_index
{
   static const bool value = false;
};

template <typename T> T*
addressof(T& v)
{
  return reinterpret_cast<T*>(
       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
}


template<class Cont>
class value_eraser
{
   public:
   value_eraser(Cont & cont, typename Cont::iterator it)
      : m_cont(cont), m_index_it(it), m_erase(true){}
   ~value_eraser()
   { if(m_erase) m_cont.erase(m_index_it); }

   void release() { m_erase = false; }

   private:
   Cont &m_cont;
   typename Cont::iterator m_index_it;
   bool m_erase;
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 158 "/opt/sevenflow/boost/include/boost/interprocess/detail/utilities.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp" 2

# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdarg.h" 1 3 4
# 98 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 34 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp" 2






# 1 "/usr/include/errno.h" 1 3 4
# 31 "/usr/include/errno.h" 3 4
extern "C" {



# 1 "/usr/include/bits/errno.h" 1 3 4
# 24 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/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/asm/errno.h" 2 3 4
# 1 "/usr/include/linux/errno.h" 2 3 4
# 25 "/usr/include/bits/errno.h" 2 3 4
# 50 "/usr/include/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;
# 41 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstring" 1 3
# 39 "/usr/include/c++/4.8.2/cstring" 3
       
# 40 "/usr/include/c++/4.8.2/cstring" 3


# 1 "/usr/include/string.h" 1 3 4
# 27 "/usr/include/string.h" 3 4
extern "C" {




# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/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)));
# 90 "/usr/include/string.h" 3 4
}










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






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










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






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







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





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







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







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)));
# 642 "/usr/include/string.h" 3 4
}
# 43 "/usr/include/c++/4.8.2/cstring" 2 3
# 71 "/usr/include/c++/4.8.2/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.2/cstring" 3

}
# 42 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp" 2
# 50 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp"
namespace boost {
namespace interprocess {

inline int system_error_code()
{



   return (*__errno_location ());

}
# 85 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp"
inline void fill_system_message( int system_error, std::string &str)
{ str = std::strerror(system_error); }



enum error_code_t
{
   no_error = 0,
   system_error,

   other_error,
   security_error,
   read_only_error,
   io_error,
   path_error,
   not_found_error,

   busy_error,
   already_exists_error,
   not_empty_error,
   is_directory_error,
   out_of_space_error,
   out_of_memory_error,
   out_of_resource_error,
   lock_error,
   sem_error,
   mode_error,
   size_error,
   corrupted_error,
   not_such_file_or_directory,
   invalid_argument,
   timeout_when_locking_error,
   timeout_when_waiting_error,
};

typedef int native_error_t;


struct ec_xlate
{
   native_error_t sys_ec;
   error_code_t ec;
};

static const ec_xlate ec_table[] =
{
# 165 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp"
   { 13, security_error },
   { 30, read_only_error },
   { 5, io_error },
   { 36, path_error },
   { 2, not_found_error },

   { 11, busy_error },
   { 16, busy_error },
   { 26, busy_error },
   { 17, already_exists_error },
   { 39, not_empty_error },
   { 21, is_directory_error },
   { 28, out_of_space_error },
   { 12, out_of_memory_error },
   { 24, out_of_resource_error },
   { 2, not_such_file_or_directory },
   { 22, invalid_argument }

};

inline error_code_t lookup_error(native_error_t err)
{
   const ec_xlate *cur = &ec_table[0],
                  *end = cur + sizeof(ec_table)/sizeof(ec_xlate);
   for (;cur != end; ++cur ){
      if ( err == cur->sys_ec ) return cur->ec;
   }
   return system_error;
}

struct error_info
{
   error_info(error_code_t ec = other_error )
      : m_nat(0), m_ec(ec)
   {}

   error_info(native_error_t sys_err_code)
      : m_nat(sys_err_code), m_ec(lookup_error(sys_err_code))
   {}

   error_info & operator =(error_code_t ec)
   {
      m_nat = 0;
      m_ec = ec;
      return *this;
   }

   error_info & operator =(native_error_t sys_err_code)
   {
      m_nat = sys_err_code;
      m_ec = lookup_error(sys_err_code);
      return *this;
   }

   native_error_t get_native_error()const
   { return m_nat; }

   error_code_t get_error_code()const
   { return m_ec; }

   private:
   native_error_t m_nat;
   error_code_t m_ec;
};


}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 235 "/opt/sevenflow/boost/include/boost/interprocess/errors.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/permissions.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/interprocess/permissions.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/permissions.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/interprocess/permissions.hpp"
namespace boost {
namespace interprocess {
# 62 "/opt/sevenflow/boost/include/boost/interprocess/permissions.hpp"
class permissions
{





   typedef int os_permissions_type;

   os_permissions_type m_perm;



   public:


   permissions(os_permissions_type type)
      : m_perm(type)
   {}




   permissions()
   { set_default(); }




   void set_default()
   {




      m_perm = 0644;


   }



   void set_unrestricted()
   {




      m_perm = 0666;


   }



   void set_permissions(os_permissions_type perm)
   { m_perm = perm; }



   os_permissions_type get_permissions() const
   { return m_perm; }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 130 "/opt/sevenflow/boost/include/boost/interprocess/permissions.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2


# 1 "/usr/include/c++/4.8.2/limits" 1 3
# 40 "/usr/include/c++/4.8.2/limits" 3
       
# 41 "/usr/include/c++/4.8.2/limits" 3
# 147 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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 -9223372036854775807L - 1; }

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






      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);



      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;

      static long
      epsilon() throw() { return 0; }

      static long
      round_error() throw() { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm
       = denorm_absent;
      static const bool has_denorm_loss = false;

      static long
      infinity() throw() { return static_cast<long>(0); }

      static long
      quiet_NaN() throw() { return static_cast<long>(0); }

      static long
      signaling_NaN() throw() { return static_cast<long>(0); }

      static long
      denorm_min() throw() { return static_cast<long>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = 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 9223372036854775807L * 2UL + 1; }






      static const int digits
       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static const int digits10
       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);



      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;

      static unsigned long
      epsilon() throw() { return 0; }

      static unsigned long
      round_error() throw() { return 0; }

      static const int min_exponent = 0;
      static const int min_exponent10 = 0;
      static const int max_exponent = 0;
      static const int max_exponent10 = 0;

      static const bool has_infinity = false;
      static const bool has_quiet_NaN = false;
      static const bool has_signaling_NaN = false;
      static const float_denorm_style has_denorm
       = denorm_absent;
      static const bool has_denorm_loss = false;

      static unsigned long
      infinity() throw()
      { return static_cast<unsigned long>(0); }

      static unsigned long
      quiet_NaN() throw()
      { return static_cast<unsigned long>(0); }

      static unsigned long
      signaling_NaN() throw()
      { return static_cast<unsigned long>(0); }

      static unsigned long
      denorm_min() throw()
      { return static_cast<unsigned long>(0); }

      static const bool is_iec559 = false;
      static const bool is_bounded = true;
      static const bool is_modulo = true;

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



  template<>
    struct numeric_limits<__int128>
    {
      static const bool is_specialized = true;

      static __int128
      min() throw() { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((sizeof(__int128) * 8 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); }

      static __int128
      max() throw() { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((sizeof(__int128) * 8 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); }






      static const int digits
       = (sizeof(__int128) * 8 - ((__int128)(-1) < 0));
      static const int digits10
       = ((sizeof(__int128) * 8 - ((__int128)(-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 __int128
      epsilon() throw() { return 0; }

      static __int128
      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 __int128
      infinity() throw()
      { return static_cast<__int128>(0); }

      static __int128
      quiet_NaN() throw()
      { return static_cast<__int128>(0); }

      static __int128
      signaling_NaN() throw()
      { return static_cast<__int128>(0); }

      static __int128
      denorm_min() throw()
      { return static_cast<__int128>(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 __int128>
    {
      static const bool is_specialized = true;

      static unsigned __int128
      min() throw() { return 0; }

      static unsigned __int128
      max() throw() { return (((unsigned __int128)(-1) < 0) ? (((((unsigned __int128)1 << ((sizeof(unsigned __int128) * 8 - ((unsigned __int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(unsigned __int128)0); }






      static const int digits
       = (sizeof(unsigned __int128) * 8 - ((unsigned __int128)(-1) < 0));
      static const int digits10
       = ((sizeof(unsigned __int128) * 8 - ((unsigned __int128)(-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 __int128
      epsilon() throw() { return 0; }

      static unsigned __int128
      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 __int128
      infinity() throw()
      { return static_cast<unsigned __int128>(0); }

      static unsigned __int128
      quiet_NaN() throw()
      { return static_cast<unsigned __int128>(0); }

      static unsigned __int128
      signaling_NaN() throw()
      { return static_cast<unsigned __int128>(0); }

      static unsigned __int128
      denorm_min() throw()
      { return static_cast<unsigned __int128>(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<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;
    };






}
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 1 "/usr/include/c++/4.8.2/climits" 1 3
# 39 "/usr/include/c++/4.8.2/climits" 3
       
# 40 "/usr/include/c++/4.8.2/climits" 3

# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 34 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 168 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 160 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 38 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 2 3 4
# 161 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 33 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 2 3 4
# 153 "/usr/include/limits.h" 2 3 4
# 169 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/syslimits.h" 2 3 4
# 35 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 2 3 4
# 42 "/usr/include/c++/4.8.2/climits" 2 3
# 22 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2





# 1 "/usr/include/fcntl.h" 1 3 4
# 28 "/usr/include/fcntl.h" 3 4
extern "C" {






# 1 "/usr/include/bits/fcntl.h" 1 3 4
# 35 "/usr/include/bits/fcntl.h" 3 4
struct flock
  {
    short int l_type;
    short int l_whence;

    __off_t l_start;
    __off_t l_len;




    __pid_t l_pid;
  };


struct flock64
  {
    short int l_type;
    short int l_whence;
    __off64_t l_start;
    __off64_t l_len;
    __pid_t l_pid;
  };



# 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
# 38 "/usr/include/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/bits/uio.h" 1 3 4
# 43 "/usr/include/bits/uio.h" 3 4
struct iovec
  {
    void *iov_base;
    size_t iov_len;
  };
# 39 "/usr/include/bits/fcntl-linux.h" 2 3 4
# 237 "/usr/include/bits/fcntl-linux.h" 3 4
enum __pid_type
  {
    F_OWNER_TID = 0,
    F_OWNER_PID,
    F_OWNER_PGRP,
    F_OWNER_GID = F_OWNER_PGRP
  };


struct f_owner_ex
  {
    enum __pid_type type;
    __pid_t pid;
  };
# 300 "/usr/include/bits/fcntl-linux.h" 3 4
struct file_handle
{
  unsigned int handle_bytes;
  int handle_type;

  unsigned char f_handle[0];
};





extern "C" {




extern ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
    throw ();






extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
       unsigned int __flags);






extern ssize_t vmsplice (int __fdout, const struct iovec *__iov,
    size_t __count, unsigned int __flags);





extern ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
         __off64_t *__offout, size_t __len,
         unsigned int __flags);





extern ssize_t tee (int __fdin, int __fdout, size_t __len,
      unsigned int __flags);






extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
# 367 "/usr/include/bits/fcntl-linux.h" 3 4
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
   __off64_t __len);




extern int name_to_handle_at (int __dfd, const char *__name,
         struct file_handle *__handle, int *__mnt_id,
         int __flags) throw ();





extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
         int __flags);



}
# 61 "/usr/include/bits/fcntl.h" 2 3 4
# 36 "/usr/include/fcntl.h" 2 3 4
# 68 "/usr/include/fcntl.h" 3 4
# 1 "/usr/include/bits/stat.h" 1 3 4
# 46 "/usr/include/bits/stat.h" 3 4
struct stat
  {
    __dev_t st_dev;




    __ino_t st_ino;







    __nlink_t st_nlink;
    __mode_t st_mode;

    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;

    __dev_t st_rdev;




    __off_t st_size;



    __blksize_t st_blksize;

    __blkcnt_t st_blocks;
# 91 "/usr/include/bits/stat.h" 3 4
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 106 "/usr/include/bits/stat.h" 3 4
    __syscall_slong_t __unused[3];
# 115 "/usr/include/bits/stat.h" 3 4
  };



struct stat64
  {
    __dev_t st_dev;

    __ino64_t st_ino;
    __nlink_t st_nlink;
    __mode_t st_mode;






    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;
    __dev_t st_rdev;
    __off_t st_size;





    __blksize_t st_blksize;
    __blkcnt64_t st_blocks;







    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 164 "/usr/include/bits/stat.h" 3 4
    __syscall_slong_t __unused[3];



  };
# 69 "/usr/include/fcntl.h" 2 3 4
# 154 "/usr/include/fcntl.h" 3 4
extern int fcntl (int __fd, int __cmd, ...);
# 163 "/usr/include/fcntl.h" 3 4
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 173 "/usr/include/fcntl.h" 3 4
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 187 "/usr/include/fcntl.h" 3 4
extern int openat (int __fd, const char *__file, int __oflag, ...)
     __attribute__ ((__nonnull__ (2)));
# 198 "/usr/include/fcntl.h" 3 4
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
     __attribute__ ((__nonnull__ (2)));
# 209 "/usr/include/fcntl.h" 3 4
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 219 "/usr/include/fcntl.h" 3 4
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 255 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
     int __advise) throw ();
# 267 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
       int __advise) throw ();
# 277 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
# 288 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
# 299 "/usr/include/fcntl.h" 3 4
}
# 28 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2


# 1 "/usr/include/sys/stat.h" 1 3 4
# 104 "/usr/include/sys/stat.h" 3 4
extern "C" {

# 1 "/usr/include/bits/stat.h" 1 3 4
# 107 "/usr/include/sys/stat.h" 2 3 4
# 210 "/usr/include/sys/stat.h" 3 4
extern int stat (const char *__restrict __file,
   struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));



extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
# 229 "/usr/include/sys/stat.h" 3 4
extern int stat64 (const char *__restrict __file,
     struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));







extern int fstatat (int __fd, const char *__restrict __file,
      struct stat *__restrict __buf, int __flag)
     throw () __attribute__ ((__nonnull__ (2, 3)));
# 254 "/usr/include/sys/stat.h" 3 4
extern int fstatat64 (int __fd, const char *__restrict __file,
        struct stat64 *__restrict __buf, int __flag)
     throw () __attribute__ ((__nonnull__ (2, 3)));







extern int lstat (const char *__restrict __file,
    struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
# 277 "/usr/include/sys/stat.h" 3 4
extern int lstat64 (const char *__restrict __file,
      struct stat64 *__restrict __buf)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern int chmod (const char *__file, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int lchmod (const char *__file, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));




extern int fchmod (int __fd, __mode_t __mode) throw ();





extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
       int __flag)
     throw () __attribute__ ((__nonnull__ (2))) ;






extern __mode_t umask (__mode_t __mask) throw ();




extern __mode_t getumask (void) throw ();



extern int mkdir (const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (2)));






extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mknodat (int __fd, const char *__path, __mode_t __mode,
      __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));





extern int mkfifo (const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (1)));





extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
     throw () __attribute__ ((__nonnull__ (2)));





extern int utimensat (int __fd, const char *__path,
        const struct timespec __times[2],
        int __flags)
     throw () __attribute__ ((__nonnull__ (2)));




extern int futimens (int __fd, const struct timespec __times[2]) throw ();
# 400 "/usr/include/sys/stat.h" 3 4
extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
     throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat (int __ver, const char *__filename,
      struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat (int __ver, const char *__filename,
       struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat (int __ver, int __fildes, const char *__filename,
         struct stat *__stat_buf, int __flag)
     throw () __attribute__ ((__nonnull__ (3, 4)));
# 433 "/usr/include/sys/stat.h" 3 4
extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
     throw () __attribute__ ((__nonnull__ (3)));
extern int __xstat64 (int __ver, const char *__filename,
        struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __lxstat64 (int __ver, const char *__filename,
         struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
extern int __fxstatat64 (int __ver, int __fildes, const char *__filename,
    struct stat64 *__stat_buf, int __flag)
     throw () __attribute__ ((__nonnull__ (3, 4)));

extern int __xmknod (int __ver, const char *__path, __mode_t __mode,
       __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));

extern int __xmknodat (int __ver, int __fd, const char *__path,
         __mode_t __mode, __dev_t *__dev)
     throw () __attribute__ ((__nonnull__ (3, 5)));
# 535 "/usr/include/sys/stat.h" 3 4
}
# 31 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 1 "/usr/include/errno.h" 1 3 4
# 32 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstdio" 1 3
# 39 "/usr/include/c++/4.8.2/cstdio" 3
       
# 40 "/usr/include/c++/4.8.2/cstdio" 3


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



# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/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/x86_64-redhat-linux/4.8.2/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
# 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
# 108 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;
# 164 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/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 ();








extern FILE *tmpfile (void) ;
# 205 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;



extern char *tmpnam (char *__s) throw () ;





extern char *tmpnam_r (char *__s) throw () ;
# 227 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
     throw () __attribute__ ((__malloc__)) ;








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









extern FILE *fopen (const char *__restrict __filename,
      const char *__restrict __modes) ;




extern FILE *freopen (const char *__restrict __filename,
        const char *__restrict __modes,
        FILE *__restrict __stream) ;
# 295 "/usr/include/stdio.h" 3 4


extern FILE *fopen64 (const char *__restrict __filename,
        const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
   const char *__restrict __modes,
   FILE *__restrict __stream) ;




extern FILE *fdopen (int __fd, const char *__modes) throw () ;





extern FILE *fopencookie (void *__restrict __magic_cookie,
     const char *__restrict __modes,
     _IO_cookie_io_functions_t __io_funcs) throw () ;




extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
  throw () ;




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;






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))) ;
extern int __asprintf (char **__restrict __ptr,
         const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
       const char *__restrict __fmt, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;




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




extern int scanf (const char *__restrict __format, ...) ;

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





extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
     __attribute__ ((__format__ (__scanf__, 1, 0))) ;


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)
     ;
# 638 "/usr/include/stdio.h" 3 4
extern char *gets (char *__s) __attribute__ ((__deprecated__));


# 649 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) ;
# 665 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
          size_t *__restrict __n, int __delimiter,
          FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
        size_t *__restrict __n, int __delimiter,
        FILE *__restrict __stream) ;







extern __ssize_t getline (char **__restrict __lineptr,
       size_t *__restrict __n,
       FILE *__restrict __stream) ;








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




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




extern void rewind (FILE *__stream);

# 773 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);




extern __off_t ftello (FILE *__stream) ;
# 792 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 815 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
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 () ;

extern int ferror (FILE *__stream) throw () ;




extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;








extern void perror (const char *__s);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/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 () ;




extern int fileno_unlocked (FILE *__stream) throw () ;
# 873 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;





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


extern void funlockfile (FILE *__stream) throw ();
# 943 "/usr/include/stdio.h" 3 4
}
# 43 "/usr/include/c++/4.8.2/cstdio" 2 3
# 93 "/usr/include/c++/4.8.2/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.2/cstdio" 3
namespace __gnu_cxx
{
# 167 "/usr/include/c++/4.8.2/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;
}
# 33 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 1 "/usr/include/dirent.h" 1 3 4
# 28 "/usr/include/dirent.h" 3 4
extern "C" {
# 62 "/usr/include/dirent.h" 3 4
# 1 "/usr/include/bits/dirent.h" 1 3 4
# 22 "/usr/include/bits/dirent.h" 3 4
struct dirent
  {

    __ino_t d_ino;
    __off_t d_off;




    unsigned short int d_reclen;
    unsigned char d_type;
    char d_name[256];
  };


struct dirent64
  {
    __ino64_t d_ino;
    __off64_t d_off;
    unsigned short int d_reclen;
    unsigned char d_type;
    char d_name[256];
  };
# 63 "/usr/include/dirent.h" 2 3 4
# 98 "/usr/include/dirent.h" 3 4
enum
  {
    DT_UNKNOWN = 0,

    DT_FIFO = 1,

    DT_CHR = 2,

    DT_DIR = 4,

    DT_BLK = 6,

    DT_REG = 8,

    DT_LNK = 10,

    DT_SOCK = 12,

    DT_WHT = 14

  };
# 128 "/usr/include/dirent.h" 3 4
typedef struct __dirstream DIR;






extern DIR *opendir (const char *__name) __attribute__ ((__nonnull__ (1)));






extern DIR *fdopendir (int __fd);







extern int closedir (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
# 163 "/usr/include/dirent.h" 3 4
extern struct dirent *readdir (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
# 174 "/usr/include/dirent.h" 3 4
extern struct dirent64 *readdir64 (DIR *__dirp) __attribute__ ((__nonnull__ (1)));
# 184 "/usr/include/dirent.h" 3 4
extern int readdir_r (DIR *__restrict __dirp,
        struct dirent *__restrict __entry,
        struct dirent **__restrict __result)
     __attribute__ ((__nonnull__ (1, 2, 3)));
# 201 "/usr/include/dirent.h" 3 4
extern int readdir64_r (DIR *__restrict __dirp,
   struct dirent64 *__restrict __entry,
   struct dirent64 **__restrict __result)
     __attribute__ ((__nonnull__ (1, 2, 3)));




extern void rewinddir (DIR *__dirp) throw () __attribute__ ((__nonnull__ (1)));





extern void seekdir (DIR *__dirp, long int __pos) throw () __attribute__ ((__nonnull__ (1)));


extern long int telldir (DIR *__dirp) throw () __attribute__ ((__nonnull__ (1)));





extern int dirfd (DIR *__dirp) throw () __attribute__ ((__nonnull__ (1)));
# 245 "/usr/include/dirent.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 246 "/usr/include/dirent.h" 2 3 4
# 255 "/usr/include/dirent.h" 3 4
extern int scandir (const char *__restrict __dir,
      struct dirent ***__restrict __namelist,
      int (*__selector) (const struct dirent *),
      int (*__cmp) (const struct dirent **,
      const struct dirent **))
     __attribute__ ((__nonnull__ (1, 2)));
# 278 "/usr/include/dirent.h" 3 4
extern int scandir64 (const char *__restrict __dir,
        struct dirent64 ***__restrict __namelist,
        int (*__selector) (const struct dirent64 *),
        int (*__cmp) (const struct dirent64 **,
        const struct dirent64 **))
     __attribute__ ((__nonnull__ (1, 2)));
# 293 "/usr/include/dirent.h" 3 4
extern int scandirat (int __dfd, const char *__restrict __dir,
        struct dirent ***__restrict __namelist,
        int (*__selector) (const struct dirent *),
        int (*__cmp) (const struct dirent **,
        const struct dirent **))
     __attribute__ ((__nonnull__ (2, 3)));
# 315 "/usr/include/dirent.h" 3 4
extern int scandirat64 (int __dfd, const char *__restrict __dir,
   struct dirent64 ***__restrict __namelist,
   int (*__selector) (const struct dirent64 *),
   int (*__cmp) (const struct dirent64 **,
          const struct dirent64 **))
     __attribute__ ((__nonnull__ (2, 3)));




extern int alphasort (const struct dirent **__e1,
        const struct dirent **__e2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 340 "/usr/include/dirent.h" 3 4
extern int alphasort64 (const struct dirent64 **__e1,
   const struct dirent64 **__e2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 353 "/usr/include/dirent.h" 3 4
extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
    size_t __nbytes,
    __off_t *__restrict __basep)
     throw () __attribute__ ((__nonnull__ (2, 4)));
# 370 "/usr/include/dirent.h" 3 4
extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
      size_t __nbytes,
      __off64_t *__restrict __basep)
     throw () __attribute__ ((__nonnull__ (2, 4)));






extern int versionsort (const struct dirent **__e1,
   const struct dirent **__e2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 396 "/usr/include/dirent.h" 3 4
extern int versionsort64 (const struct dirent64 **__e1,
     const struct dirent64 **__e2)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



}
# 34 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp"
# 1 "/usr/include/c++/4.8.2/cstring" 1 3
# 39 "/usr/include/c++/4.8.2/cstring" 3
       
# 40 "/usr/include/c++/4.8.2/cstring" 3
# 43 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
# 39 "/usr/include/c++/4.8.2/cstdlib" 3
       
# 40 "/usr/include/c++/4.8.2/cstdlib" 3
# 44 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2

namespace boost {
namespace interprocess {
# 357 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp"
typedef int file_handle_t;
typedef off_t offset_t;

typedef struct mapping_handle_impl_t
{
   file_handle_t handle;
   bool is_xsi;
} mapping_handle_t;

typedef enum { read_only = 00
             , read_write = 02
             , copy_on_write
             , read_private
             , invalid_mode = 0xffff
             } mode_t;

typedef enum { file_begin = 0
             , file_end = 2
             , file_current = 1
             } file_pos_t;

namespace ipcdetail{

inline mapping_handle_t mapping_handle_from_file_handle(file_handle_t hnd)
{
   mapping_handle_t ret;
   ret.handle = hnd;
   ret.is_xsi = false;
   return ret;
}

inline file_handle_t file_handle_from_mapping_handle(mapping_handle_t hnd)
{ return hnd.handle; }

inline bool create_directory(const char *path)
{ return ::mkdir(path, 0777) == 0 && ::chmod(path, 0777) == 0; }

inline const char *get_temporary_path()
{
   const char *names[] = {"/tmp", "TMPDIR", "TMP", "TEMP" };
   const int names_size = sizeof(names)/sizeof(names[0]);
   struct stat data;
   for(int i = 0; i != names_size; ++i){
      if(::stat(names[i], &data) == 0){
         return names[i];
      }
   }
   return "/tmp";
}

inline file_handle_t create_new_file
   (const char *name, mode_t mode, const permissions & perm = permissions(), bool temporary = false)
{
   (void)temporary;
   int ret = ::open(name, ((int)mode) | 0200 | 0100, perm.get_permissions());
   if(ret >= 0){
      ::fchmod(ret, perm.get_permissions());
   }
   return ret;
}

inline file_handle_t create_or_open_file
   (const char *name, mode_t mode, const permissions & perm = permissions(), bool temporary = false)
{
   (void)temporary;
   int ret = -1;


   while(1){
      ret = ::open(name, ((int)mode) | 0200 | 0100, perm.get_permissions());
      if(ret >= 0){
         ::fchmod(ret, perm.get_permissions());
         break;
      }
      else if((*__errno_location ()) == 17){
         if((ret = ::open(name, (int)mode)) >= 0 || (*__errno_location ()) != 2){
            break;
         }
      }
   }
   return ret;
}

inline file_handle_t open_existing_file
   (const char *name, mode_t mode, bool temporary = false)
{
   (void)temporary;
   return ::open(name, (int)mode);
}

inline bool delete_file(const char *name)
{ return ::unlink(name) == 0; }

inline bool truncate_file (file_handle_t hnd, std::size_t size)
{
   if(sizeof(off_t) == sizeof(std::size_t)){
      if(size > ((~std::size_t(0)) >> 1)){
         (*__errno_location ()) = 22;
         return false;
      }
   }
   return 0 == ::ftruncate(hnd, off_t(size));
}

inline bool get_file_size(file_handle_t hnd, offset_t &size)
{
   struct stat data;
   bool ret = 0 == ::fstat(hnd, &data);
   if(ret){
      size = data.st_size;
   }
   return ret;
}

inline bool set_file_pointer(file_handle_t hnd, offset_t off, file_pos_t pos)
{ return ((off_t)(-1)) != ::lseek(hnd, off, (int)pos); }

inline bool get_file_pointer(file_handle_t hnd, offset_t &off)
{
   off = ::lseek(hnd, 0, 1);
   return off != ((off_t)-1);
}

inline bool write_file(file_handle_t hnd, const void *data, std::size_t numdata)
{ return (ssize_t(numdata)) == ::write(hnd, data, numdata); }

inline file_handle_t invalid_file()
{ return -1; }

inline bool close_file(file_handle_t hnd)
{ return ::close(hnd) == 0; }

inline bool acquire_file_lock(file_handle_t hnd)
{
   struct ::flock lock;
   lock.l_type = 1;
   lock.l_whence = 0;
   lock.l_start = 0;
   lock.l_len = 0;
   return -1 != ::fcntl(hnd, 7, &lock);
}

inline bool try_acquire_file_lock(file_handle_t hnd, bool &acquired)
{
   struct ::flock lock;
   lock.l_type = 1;
   lock.l_whence = 0;
   lock.l_start = 0;
   lock.l_len = 0;
   int ret = ::fcntl(hnd, 6, &lock);
   if(ret == -1){
      return ((*__errno_location ()) == 11 || (*__errno_location ()) == 13) ?
               acquired = false, true : false;
   }
   return (acquired = true);
}

inline bool release_file_lock(file_handle_t hnd)
{
   struct ::flock lock;
   lock.l_type = 2;
   lock.l_whence = 0;
   lock.l_start = 0;
   lock.l_len = 0;
   return -1 != ::fcntl(hnd, 6, &lock);
}

inline bool acquire_file_lock_sharable(file_handle_t hnd)
{
   struct ::flock lock;
   lock.l_type = 0;
   lock.l_whence = 0;
   lock.l_start = 0;
   lock.l_len = 0;
   return -1 != ::fcntl(hnd, 7, &lock);
}

inline bool try_acquire_file_lock_sharable(file_handle_t hnd, bool &acquired)
{
   struct flock lock;
   lock.l_type = 0;
   lock.l_whence = 0;
   lock.l_start = 0;
   lock.l_len = 0;
   int ret = ::fcntl(hnd, 6, &lock);
   if(ret == -1){
      return ((*__errno_location ()) == 11 || (*__errno_location ()) == 13) ?
               acquired = false, true : false;
   }
   return (acquired = true);
}

inline bool release_file_lock_sharable(file_handle_t hnd)
{ return release_file_lock(hnd); }
# 580 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp"
inline bool delete_subdirectories_recursive
   (const std::string &refcstrRootDirectory, const char *dont_delete_this)
{
   DIR *d = opendir(refcstrRootDirectory.c_str());
   if(!d) {
      return false;
   }

   struct dir_close
   {
      DIR *d_;
      dir_close(DIR *d) : d_(d) {}
      ~dir_close() { ::closedir(d_); }
   } dc(d); (void)dc;

   struct ::dirent *de;
   struct ::stat st;
   std::string fn;

   while((de=::readdir(d))) {
      if( de->d_name[0] == '.' && ( de->d_name[1] == '\0'
            || (de->d_name[1] == '.' && de->d_name[2] == '\0' )) ){
         continue;
      }
      if(dont_delete_this && std::strcmp(dont_delete_this, de->d_name) == 0){
         continue;
      }
      fn = refcstrRootDirectory;
      fn += '/';
      fn += de->d_name;

      if(std::remove(fn.c_str())) {
         if(::stat(fn.c_str(), & st)) {
            return false;
         }
         if(((((st.st_mode)) & 0170000) == (0040000))) {
            if(!delete_subdirectories_recursive(fn, 0) ){
               return false;
            }
         } else {
            return false;
         }
      }
   }
   return std::remove(refcstrRootDirectory.c_str()) ? false : true;
}

template<class Function>
inline bool for_each_file_in_dir(const char *dir, Function f)
{
   std::string refcstrRootDirectory(dir);

   DIR *d = opendir(refcstrRootDirectory.c_str());
   if(!d) {
      return false;
   }

   struct dir_close
   {
      DIR *d_;
      dir_close(DIR *d) : d_(d) {}
      ~dir_close() { ::closedir(d_); }
   } dc(d); (void)dc;

   struct ::dirent *de;
   struct ::stat st;
   std::string fn;

   while((de=::readdir(d))) {
      if( de->d_name[0] == '.' && ( de->d_name[1] == '\0'
            || (de->d_name[1] == '.' && de->d_name[2] == '\0' )) ){
         continue;
      }
      fn = refcstrRootDirectory;
      fn += '/';
      fn += de->d_name;

      if(::stat(fn.c_str(), & st)) {
         return false;
      }

      if(!((((st.st_mode)) & 0170000) == (0040000))) {
         f(fn.c_str(), de->d_name);
      }
   }
   return true;
}



inline bool delete_subdirectories(const std::string &refcstrRootDirectory, const char *dont_delete_this)
{
   return delete_subdirectories_recursive(refcstrRootDirectory, dont_delete_this );
}



inline bool open_or_create_directory(const char *dir_name)
{

   if(!create_directory(dir_name)){
      error_info info(system_error_code());
      if(info.get_error_code() != already_exists_error){
         return false;
      }
   }
   return true;
}


}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 695 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_file_functions.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/creation_tags.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/creation_tags.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/creation_tags.hpp" 2


namespace boost {
namespace interprocess {



struct create_only_t {};



struct open_only_t {};



struct open_read_only_t {};



struct open_read_private_t {};



struct open_copy_on_write_t {};



struct open_or_create_t {};



static const create_only_t create_only = create_only_t();



static const open_only_t open_only = open_only_t();



static const open_read_only_t open_read_only = open_read_only_t();



static const open_or_create_t open_or_create = open_or_create_t();



static const open_copy_on_write_t open_copy_on_write = open_copy_on_write_t();

namespace ipcdetail {

enum create_enum_t
{ DoCreate, DoOpen, DoOpenOrCreate };

}

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 75 "/opt/sevenflow/boost/include/boost/interprocess/creation_tags.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp" 2


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




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

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




}
# 22 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp" 2





namespace boost {

namespace interprocess {



class interprocess_exception : public std::exception
{
   public:
   interprocess_exception(const char *err )
      : m_err(other_error)
   {

      try { m_str = err; }
      catch (...) {}
   }
# 51 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp"
   interprocess_exception(const error_info &err_info, const char *str = 0)
      : m_err(err_info)
   {
      try{
         if(m_err.get_native_error() != 0){
            fill_system_message(m_err.get_native_error(), m_str);
         }
         else if(str){
            m_str = str;
         }
         else{
            m_str = "boost::interprocess_exception::library_error";
         }
      }
      catch(...){}
   }

   virtual ~interprocess_exception() throw(){}

   virtual const char * what() const throw()
   { return m_str.c_str(); }

   native_error_t get_native_error()const { return m_err.get_native_error(); }


   error_code_t get_error_code() const { return m_err.get_error_code(); }


   private:
   error_info m_err;
   std::string m_str;

};



class lock_exception : public interprocess_exception
{
   public:
   lock_exception()
      : interprocess_exception(lock_error)
   {}

   virtual const char* what() const throw()
   { return "boost::interprocess::lock_exception"; }
};
# 136 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp"
class bad_alloc : public interprocess_exception
{
 public:
   bad_alloc() : interprocess_exception("::boost::interprocess::bad_alloc"){}
   virtual const char* what() const throw()
      { return "boost::interprocess::bad_alloc"; }
};

}

}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 149 "/opt/sevenflow/boost/include/boost/interprocess/exceptions.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/detail/no_exceptions_support.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/in_place_interface.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/in_place_interface.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/in_place_interface.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 14 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/size_t.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/size_t.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/size_t_fwd.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/size_t_fwd.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/mpl/size_t_fwd.hpp" 2

namespace mpl_ {

template< std::size_t N > struct size_t;

}
namespace boost { namespace mpl { using ::mpl_::size_t; } }
# 18 "/opt/sevenflow/boost/include/boost/mpl/size_t.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1
# 40 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
    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 "/opt/sevenflow/boost/include/boost/mpl/size_t.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp"
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
{
# 83 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp"
   static const std::size_t value = __alignof__(T);

};

}

template< typename T > struct alignment_of : public ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { public: };




template <typename T>
struct alignment_of<T&>
    : public alignment_of<T*>
{
};
# 109 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 126 "/opt/sevenflow/boost/include/boost/type_traits/alignment_of.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/interprocess/detail/in_place_interface.hpp" 2
# 1 "/usr/include/c++/4.8.2/typeinfo" 1 3
# 32 "/usr/include/c++/4.8.2/typeinfo" 3
       
# 33 "/usr/include/c++/4.8.2/typeinfo" 3






#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 80 "/usr/include/c++/4.8.2/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.2/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.2/typeinfo" 3
    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }
# 152 "/usr/include/c++/4.8.2/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
# 23 "/opt/sevenflow/boost/include/boost/interprocess/detail/in_place_interface.hpp" 2




namespace boost {
namespace interprocess {
namespace ipcdetail {

struct in_place_interface
{
   in_place_interface(std::size_t alignm, std::size_t sz, const char *tname)
   : alignment(alignm), size(sz), type_name(tname)
   {}

   std::size_t alignment;
   std::size_t size;
   const char *type_name;

   virtual void construct_n(void *mem, std::size_t num, std::size_t &constructed) = 0;
   virtual void destroy_n(void *mem, std::size_t num, std::size_t &destroyed) = 0;
   virtual ~in_place_interface(){}
};

template<class T>
struct placement_destroy : public in_place_interface
{
   placement_destroy()
    : in_place_interface(::boost::alignment_of<T>::value, sizeof(T), typeid(T).name())
   {}

   virtual void destroy_n(void *mem, std::size_t num, std::size_t &destroyed)
   {
      T* memory = static_cast<T*>(mem);
      for(destroyed = 0; destroyed < num; ++destroyed)
         (memory++)->~T();
   }

   virtual void construct_n(void *, std::size_t, std::size_t &) {}

   private:
   void destroy(void *mem)
   { static_cast<T*>(mem)->~T(); }
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 72 "/opt/sevenflow/boost/include/boost/interprocess/detail/in_place_interface.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/if.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/value_wknd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/value_wknd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/integral.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/value_wknd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/eti.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/value_wknd.hpp" 2
# 73 "/opt/sevenflow/boost/include/boost/mpl/aux_/value_wknd.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename T > struct value_type_wknd
{
    typedef typename T::value_type type;
};
# 87 "/opt/sevenflow/boost/include/boost/mpl/aux_/value_wknd.hpp"
}}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/if.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_spec.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_spec.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/lambda_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/lambda_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/void_fwd.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/void_fwd.hpp"
namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/opt/sevenflow/boost/include/boost/mpl/lambda_fwd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/na.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/na.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_fwd.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_fwd.hpp"
namespace mpl_ {


struct na
{
    typedef na type;
    enum { value = 0 };
};

}
namespace boost { namespace mpl { using ::mpl_::na; } }
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/na.hpp" 2



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 "/opt/sevenflow/boost/include/boost/mpl/aux_/na.hpp"
}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/lambda_fwd.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/lambda_arity_param.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/lambda_fwd.hpp" 2


namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Arity = int_< aux::template_arity<T>::value >


    >
struct lambda;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_spec.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/arity.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/arity.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/dtp.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/arity.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_spec.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/enum.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_spec.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/limits/arity.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/preprocessor/logical/and.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/identity.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/preprocessor/identity.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/facilities/identity.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/identity.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/empty.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_spec.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/if.hpp" 2





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 "/opt/sevenflow/boost/include/boost/mpl/if.hpp"
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> { }; }

}}
# 13 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_signed.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/type_traits/is_signed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_signed.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_signed.hpp"
}






template< typename T > struct is_signed : public ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 139 "/opt/sevenflow/boost/include/boost/type_traits/is_signed.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_unsigned.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/type_traits/is_unsigned.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_unsigned.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_unsigned.hpp"
}






template< typename T > struct is_unsigned : public ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 134 "/opt/sevenflow/boost/include/boost/type_traits/is_unsigned.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_const.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/is_const.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/type_traits/is_const.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_const.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 163 "/opt/sevenflow/boost/include/boost/type_traits/is_const.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_const.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/type_traits/add_const.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/type_traits/add_const.hpp" 2

namespace boost {
# 33 "/opt/sevenflow/boost/include/boost/type_traits/add_const.hpp"
template< typename T > struct add_const { public: typedef T const type; };






template< typename T > struct add_const<T&> { public: typedef T& type; };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 46 "/opt/sevenflow/boost/include/boost/type_traits/add_const.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_volatile.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/type_traits/add_volatile.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/type_traits/add_volatile.hpp" 2

namespace boost {
# 33 "/opt/sevenflow/boost/include/boost/type_traits/add_volatile.hpp"
template< typename T > struct add_volatile { public: typedef T volatile type; };






template< typename T > struct add_volatile<T&> { public: typedef T& type; };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 46 "/opt/sevenflow/boost/include/boost/type_traits/add_volatile.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2

namespace boost {

namespace detail {

template <class T>
struct make_unsigned_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_39
                                                                                                         ;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_43

                                                            ;


   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_unsigned<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, signed char>,
            unsigned char,
            typename mpl::if_<
               is_same<t_no_cv, short>,
               unsigned short,
               typename mpl::if_<
                  is_same<t_no_cv, int>,
                  unsigned int,
                  typename mpl::if_<
                     is_same<t_no_cv, long>,
                     unsigned long,

                     boost::ulong_long_type





                  >::type
               >::type
            >::type
         >::type,

         typename mpl::if_c<
            sizeof(t_no_cv) == sizeof(unsigned char),
            unsigned char,
            typename mpl::if_c<
               sizeof(t_no_cv) == sizeof(unsigned short),
               unsigned short,
               typename mpl::if_c<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  unsigned int,
                  typename mpl::if_c<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     unsigned long,

                     boost::ulong_long_type





                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename mpl::if_<
      is_const<T>,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;


   typedef typename mpl::if_<
      is_volatile<T>,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};


}

template< typename T > struct make_unsigned { public: typedef typename boost::detail::make_unsigned_imp<T>::type type; };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 135 "/opt/sevenflow/boost/include/boost/type_traits/make_unsigned.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 32 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 81 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
# 39 "/usr/include/c++/4.8.2/cstdlib" 3
       
# 40 "/usr/include/c++/4.8.2/cstdlib" 3
# 82 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 1 "/usr/include/c++/4.8.2/iostream" 1 3
# 36 "/usr/include/c++/4.8.2/iostream" 3
       
# 37 "/usr/include/c++/4.8.2/iostream" 3





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

# 60 "/usr/include/c++/4.8.2/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/current_function.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/current_function.hpp"
namespace boost
{

namespace detail
{

inline void current_function_helper()
{
# 61 "/opt/sevenflow/boost/include/boost/current_function.hpp"
}

}

}
# 84 "/opt/sevenflow/boost/include/boost/assert.hpp" 2







    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();
          }
        }
      }
    }
# 36 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 2
# 45 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp"
namespace boost{
namespace interprocess{

template<class MemoryManager>
class segment_manager_base;



enum instance_type { anonymous_type, named_type, unique_type, max_allocation_type };

namespace ipcdetail{

template<class MemoryAlgorithm>
class mem_algo_deallocator
{
   void * m_ptr;
   MemoryAlgorithm & m_algo;

   public:
   mem_algo_deallocator(void *ptr, MemoryAlgorithm &algo)
      : m_ptr(ptr), m_algo(algo)
   {}

   void release()
   { m_ptr = 0; }

   ~mem_algo_deallocator()
   { if(m_ptr) m_algo.deallocate(m_ptr); }
};


template<class size_type>
struct block_header
{
   size_type m_value_bytes;
   unsigned short m_num_char;
   unsigned char m_value_alignment;
   unsigned char m_alloc_type_sizeof_char;

   block_header(size_type value_bytes
               ,size_type value_alignment
               ,unsigned char alloc_type
               ,std::size_t sizeof_char
               ,std::size_t num_char
               )
      : m_value_bytes(value_bytes)
      , m_num_char((unsigned short)num_char)
      , m_value_alignment((unsigned char)value_alignment)
      , m_alloc_type_sizeof_char
         ( (alloc_type << 5u) |
           ((unsigned char)sizeof_char & 0x1F) )
   {};


   template<class T>
   block_header &operator= (const T& )
   { return *this; }

   size_type total_size() const
   {
      if(alloc_type() != anonymous_type){
         return name_offset() + (m_num_char+1)*sizeof_char();
      }
      else{
         return this->value_offset() + m_value_bytes;
      }
   }

   size_type value_bytes() const
   { return m_value_bytes; }

   template<class Header>
   size_type total_size_with_header() const
   {
      return get_rounded_size
               ( size_type(sizeof(Header))
      , size_type(::boost::alignment_of<block_header<size_type> >::value))
           + total_size();
   }

   unsigned char alloc_type() const
   { return (m_alloc_type_sizeof_char >> 5u)&(unsigned char)0x7; }

   unsigned char sizeof_char() const
   { return m_alloc_type_sizeof_char & (unsigned char)0x1F; }

   template<class CharType>
   CharType *name() const
   {
      return const_cast<CharType*>(reinterpret_cast<const CharType*>
         (reinterpret_cast<const char*>(this) + name_offset()));
   }

   unsigned short name_length() const
   { return m_num_char; }

   size_type name_offset() const
   {
      return this->value_offset() + get_rounded_size(size_type(m_value_bytes), size_type(sizeof_char()));
   }

   void *value() const
   {
      return const_cast<char*>((reinterpret_cast<const char*>(this) + this->value_offset()));
   }

   size_type value_offset() const
   {
      return get_rounded_size(size_type(sizeof(block_header<size_type>)), size_type(m_value_alignment));
   }

   template<class CharType>
   bool less_comp(const block_header<size_type> &b) const
   {
      return m_num_char < b.m_num_char ||
             (m_num_char < b.m_num_char &&
               std::char_traits<CharType>::compare
                  (name<CharType>(), b.name<CharType>(), m_num_char) < 0);
   }

   template<class CharType>
   bool equal_comp(const block_header<size_type> &b) const
   {
      return m_num_char == b.m_num_char &&
             std::char_traits<CharType>::compare
               (name<CharType>(), b.name<CharType>(), m_num_char) == 0;
   }

   template<class T>
   static block_header<size_type> *block_header_from_value(T *value)
   { return block_header_from_value(value, sizeof(T), ::boost::alignment_of<T>::value); }

   static block_header<size_type> *block_header_from_value(const void *value, std::size_t sz, std::size_t algn)
   {
      block_header * hdr =
         const_cast<block_header*>
            (reinterpret_cast<const block_header*>(reinterpret_cast<const char*>(value) -
               get_rounded_size(sizeof(block_header), algn)));
      (void)sz;

      ((hdr->m_value_alignment == algn) ? static_cast<void> (0) : __assert_fail ("hdr->m_value_alignment == algn", "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp", 185, __PRETTY_FUNCTION__));
      ((hdr->m_value_bytes % sz == 0) ? static_cast<void> (0) : __assert_fail ("hdr->m_value_bytes % sz == 0", "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp", 186, __PRETTY_FUNCTION__));
      return hdr;
   }

   template<class Header>
   static block_header<size_type> *from_first_header(Header *header)
   {
      block_header<size_type> * hdr =
         reinterpret_cast<block_header<size_type>*>(reinterpret_cast<char*>(header) +
   get_rounded_size(size_type(sizeof(Header)), size_type(::boost::alignment_of<block_header<size_type> >::value)));

      return hdr;
   }

   template<class Header>
   static Header *to_first_header(block_header<size_type> *bheader)
   {
      Header * hdr =
         reinterpret_cast<Header*>(reinterpret_cast<char*>(bheader) -
   get_rounded_size(size_type(sizeof(Header)), size_type(::boost::alignment_of<block_header<size_type> >::value)));

      return hdr;
   }
};

inline void array_construct(void *mem, std::size_t num, in_place_interface &table)
{

   std::size_t constructed = 0;
   { try{
      table.construct_n(mem, num, constructed);
   }

   catch(...){
      std::size_t destroyed = 0;
      table.destroy_n(mem, constructed, destroyed);
      throw;
   }
   }
}

template<class CharT>
struct intrusive_compare_key
{
   typedef CharT char_type;

   intrusive_compare_key(const CharT *str, std::size_t len)
      : mp_str(str), m_len(len)
   {}

   const CharT * mp_str;
   std::size_t m_len;
};



template<instance_type type>
class instance_t
{
   instance_t(){}
};

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

template<>
struct char_if_void<void>
{
   typedef char type;
};

typedef instance_t<anonymous_type> anonymous_instance_t;
typedef instance_t<unique_type> unique_instance_t;


template<class Hook, class CharType, class SizeType>
struct intrusive_value_type_impl
   : public Hook
{
   private:

   intrusive_value_type_impl(const intrusive_value_type_impl &);
   intrusive_value_type_impl& operator=(const intrusive_value_type_impl &);

   public:
   typedef CharType char_type;
   typedef SizeType size_type;

   intrusive_value_type_impl(){}

   enum { BlockHdrAlignment = ::boost::alignment_of<block_header<size_type> >::value };

   block_header<size_type> *get_block_header() const
   {
      return const_cast<block_header<size_type>*>
         (reinterpret_cast<const block_header<size_type> *>(reinterpret_cast<const char*>(this) +
            get_rounded_size(size_type(sizeof(*this)), size_type(BlockHdrAlignment))));
   }

   bool operator <(const intrusive_value_type_impl<Hook, CharType, SizeType> & other) const
   { return (this->get_block_header())->template less_comp<CharType>(*other.get_block_header()); }

   bool operator ==(const intrusive_value_type_impl<Hook, CharType, SizeType> & other) const
   { return (this->get_block_header())->template equal_comp<CharType>(*other.get_block_header()); }

   static intrusive_value_type_impl *get_intrusive_value_type(block_header<size_type> *hdr)
   {
      return reinterpret_cast<intrusive_value_type_impl *>(reinterpret_cast<char*>(hdr) -
         get_rounded_size(size_type(sizeof(intrusive_value_type_impl)), size_type(BlockHdrAlignment)));
   }

   CharType *name() const
   { return get_block_header()->template name<CharType>(); }

   unsigned short name_length() const
   { return get_block_header()->name_length(); }

   void *value() const
   { return get_block_header()->value(); }
};

template<class CharType>
class char_ptr_holder
{
   public:
   char_ptr_holder(const CharType *name)
      : m_name(name)
   {}

   char_ptr_holder(const anonymous_instance_t *)
      : m_name(static_cast<CharType*>(0))
   {}

   char_ptr_holder(const unique_instance_t *)
      : m_name(reinterpret_cast<CharType*>(-1))
   {}

   operator const CharType *()
   { return m_name; }

   private:
   const CharType *m_name;
};



template<class CharT, class VoidPointer>
struct index_key
{
   typedef typename boost::intrusive::
      pointer_traits<VoidPointer>::template
         rebind_pointer<const CharT>::type const_char_ptr_t;
   typedef CharT char_type;
   typedef typename boost::intrusive::pointer_traits<const_char_ptr_t>::difference_type difference_type;
   typedef typename boost::make_unsigned<difference_type>::type size_type;

   private:

   const_char_ptr_t mp_str;

   size_type m_len;
   public:


   index_key (const char_type *name, size_type length)
      : mp_str(name), m_len(length) {}


   bool operator < (const index_key & right) const
   {
      return (m_len < right.m_len) ||
               (m_len == right.m_len &&
               std::char_traits<char_type>::compare
                  (to_raw_pointer(mp_str)
              ,to_raw_pointer(right.mp_str), m_len) < 0);
   }


   bool operator == (const index_key & right) const
   {
      return m_len == right.m_len &&
               std::char_traits<char_type>::compare
                  (to_raw_pointer(mp_str),
                   to_raw_pointer(right.mp_str), m_len) == 0;
   }

   void name(const CharT *name)
   { mp_str = name; }

   void name_length(size_type len)
   { m_len = len; }

   const CharT *name() const
   { return to_raw_pointer(mp_str); }

   size_type name_length() const
   { return m_len; }
};



template<class VoidPointer>
struct index_data
{
   typedef VoidPointer void_pointer;
   void_pointer m_ptr;
   index_data(void *ptr) : m_ptr(ptr){}

   void *value() const
   { return static_cast<void*>(to_raw_pointer(m_ptr)); }
};

template<class MemoryAlgorithm>
struct segment_manager_base_type
{ typedef segment_manager_base<MemoryAlgorithm> type; };

template<class CharT, class MemoryAlgorithm>
struct index_config
{
   typedef typename MemoryAlgorithm::void_pointer void_pointer;
   typedef CharT char_type;
   typedef index_key<CharT, void_pointer> key_type;
   typedef index_data<void_pointer> mapped_type;
   typedef typename segment_manager_base_type
      <MemoryAlgorithm>::type segment_manager_base;

   template<class HeaderBase>
   struct intrusive_value_type
   { typedef intrusive_value_type_impl<HeaderBase, CharT, typename segment_manager_base::size_type> type; };

   typedef intrusive_compare_key<CharT> intrusive_compare_key_type;
};

template<class Iterator, bool intrusive>
class segment_manager_iterator_value_adaptor
{
   typedef typename Iterator::value_type iterator_val_t;
   typedef typename iterator_val_t::char_type char_type;

   public:
   segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val)
      : m_val(&val)
   {}

   const char_type *name() const
   { return m_val->name(); }

   unsigned short name_length() const
   { return m_val->name_length(); }

   const void *value() const
   { return m_val->value(); }

   const typename Iterator::value_type *m_val;
};


template<class Iterator>
class segment_manager_iterator_value_adaptor<Iterator, false>
{
   typedef typename Iterator::value_type iterator_val_t;
   typedef typename iterator_val_t::first_type first_type;
   typedef typename iterator_val_t::second_type second_type;
   typedef typename first_type::char_type char_type;
   typedef typename first_type::size_type size_type;

   public:
   segment_manager_iterator_value_adaptor(const typename Iterator::value_type &val)
      : m_val(&val)
   {}

   const char_type *name() const
   { return m_val->first.name(); }

   size_type name_length() const
   { return m_val->first.name_length(); }

   const void *value() const
   {
      return reinterpret_cast<block_header<size_type>*>
         (to_raw_pointer(m_val->second.m_ptr))->value();
   }

   const typename Iterator::value_type *m_val;
};

template<class Iterator, bool intrusive>
struct segment_manager_iterator_transform
   : std::unary_function< typename Iterator::value_type
                         , segment_manager_iterator_value_adaptor<Iterator, intrusive> >
{
   typedef segment_manager_iterator_value_adaptor<Iterator, intrusive> result_type;

   result_type operator()(const typename Iterator::value_type &arg) const
   { return result_type(arg); }
};

}



static const ipcdetail::anonymous_instance_t * anonymous_instance = 0;
static const ipcdetail::unique_instance_t * unique_instance = 0;

namespace ipcdetail_really_deep_namespace {



struct dummy
{
   dummy()
   {
      (void)anonymous_instance;
      (void)unique_instance;
   }
};

}

}}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 511 "/opt/sevenflow/boost/include/boost/interprocess/detail/segment_manager_helper.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/preprocessor.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/preprocessor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/preprocessor.hpp" 2
# 133 "/opt/sevenflow/boost/include/boost/interprocess/detail/preprocessor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 134 "/opt/sevenflow/boost/include/boost/interprocess/detail/preprocessor.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
namespace boost {
namespace interprocess {
namespace ipcdetail {
# 138 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
template<class T>
struct Ctor0Arg : public placement_destroy<T>
{
   typedef Ctor0Arg self_t;

   Ctor0Arg(){}

   self_t& operator++() { return *this; }
   self_t operator++(int) { return *this; }

   void construct(void *mem)
   { new((void*)mem)T; }

   virtual void construct_n(void *mem, std::size_t num, std::size_t &constructed)
   {
      T* memory = static_cast<T*>(mem);
      for(constructed = 0; constructed < num; ++constructed)
         new((void*)memory++)T;
   }
};
# 269 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        template<class T, bool is_iterator, class P0 > struct Ctor1Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor1Arg self_t; void do_increment(true_) { ++m_p0; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor1Arg ( const P0 & p0 ) : m_p0 (const_cast<P0 &>(p0)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 )); } P0 & m_p0; };


        template<class T, bool is_iterator, class P0 , class P1 > struct Ctor2Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor2Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor2Arg ( const P0 & p0 , const P1 & p1 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 )); } P0 & m_p0; P1 & m_p1; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 > struct Ctor3Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor3Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor3Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 > struct Ctor4Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor4Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor4Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 , class P4 > struct Ctor5Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor5Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3 , ++m_p4; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor5Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) , m_p4 (const_cast<P4 &>(p4)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3 , *m_p4); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 ) , ::boost::forward< P4 >( m_p4 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; P4 & m_p4; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > struct Ctor6Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor6Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3 , ++m_p4 , ++m_p5; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor6Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) , m_p4 (const_cast<P4 &>(p4)) , m_p5 (const_cast<P5 &>(p5)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3 , *m_p4 , *m_p5); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 ) , ::boost::forward< P4 >( m_p4 ) , ::boost::forward< P5 >( m_p5 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; P4 & m_p4; P5 & m_p5; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > struct Ctor7Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor7Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3 , ++m_p4 , ++m_p5 , ++m_p6; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor7Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) , m_p4 (const_cast<P4 &>(p4)) , m_p5 (const_cast<P5 &>(p5)) , m_p6 (const_cast<P6 &>(p6)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3 , *m_p4 , *m_p5 , *m_p6); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 ) , ::boost::forward< P4 >( m_p4 ) , ::boost::forward< P5 >( m_p5 ) , ::boost::forward< P6 >( m_p6 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; P4 & m_p4; P5 & m_p5; P6 & m_p6; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > struct Ctor8Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor8Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3 , ++m_p4 , ++m_p5 , ++m_p6 , ++m_p7; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor8Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) , m_p4 (const_cast<P4 &>(p4)) , m_p5 (const_cast<P5 &>(p5)) , m_p6 (const_cast<P6 &>(p6)) , m_p7 (const_cast<P7 &>(p7)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3 , *m_p4 , *m_p5 , *m_p6 , *m_p7); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 ) , ::boost::forward< P4 >( m_p4 ) , ::boost::forward< P5 >( m_p5 ) , ::boost::forward< P6 >( m_p6 ) , ::boost::forward< P7 >( m_p7 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; P4 & m_p4; P5 & m_p5; P6 & m_p6; P7 & m_p7; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > struct Ctor9Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor9Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3 , ++m_p4 , ++m_p5 , ++m_p6 , ++m_p7 , ++m_p8; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor9Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) , m_p4 (const_cast<P4 &>(p4)) , m_p5 (const_cast<P5 &>(p5)) , m_p6 (const_cast<P6 &>(p6)) , m_p7 (const_cast<P7 &>(p7)) , m_p8 (const_cast<P8 &>(p8)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3 , *m_p4 , *m_p5 , *m_p6 , *m_p7 , *m_p8); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 ) , ::boost::forward< P4 >( m_p4 ) , ::boost::forward< P5 >( m_p5 ) , ::boost::forward< P6 >( m_p6 ) , ::boost::forward< P7 >( m_p7 ) , ::boost::forward< P8 >( m_p8 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; P4 & m_p4; P5 & m_p5; P6 & m_p6; P7 & m_p7; P8 & m_p8; };


        template<class T, bool is_iterator, class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > struct Ctor10Arg : public placement_destroy<T> { typedef bool_<is_iterator> IsIterator; typedef Ctor10Arg self_t; void do_increment(true_) { ++m_p0 , ++m_p1 , ++m_p2 , ++m_p3 , ++m_p4 , ++m_p5 , ++m_p6 , ++m_p7 , ++m_p8 , ++m_p9; } void do_increment(false_){} self_t& operator++() { this->do_increment(IsIterator()); return *this; } self_t operator++(int) { return ++*this; *this; } Ctor10Arg ( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9 ) : m_p0 (const_cast<P0 &>(p0)) , m_p1 (const_cast<P1 &>(p1)) , m_p2 (const_cast<P2 &>(p2)) , m_p3 (const_cast<P3 &>(p3)) , m_p4 (const_cast<P4 &>(p4)) , m_p5 (const_cast<P5 &>(p5)) , m_p6 (const_cast<P6 &>(p6)) , m_p7 (const_cast<P7 &>(p7)) , m_p8 (const_cast<P8 &>(p8)) , m_p9 (const_cast<P9 &>(p9)) {} virtual void construct_n(void *mem , std::size_t num , std::size_t &constructed) { T* memory = static_cast<T*>(mem); for(constructed = 0; constructed < num; ++constructed){ this->construct(memory++, IsIterator()); this->do_increment(IsIterator()); } } private: void construct(void *mem, true_) { new((void*)mem) T ( *m_p0 , *m_p1 , *m_p2 , *m_p3 , *m_p4 , *m_p5 , *m_p6 , *m_p7 , *m_p8 , *m_p9); } void construct(void *mem, false_) { new((void*)mem) T ( ::boost::forward< P0 >( m_p0 ) , ::boost::forward< P1 >( m_p1 ) , ::boost::forward< P2 >( m_p2 ) , ::boost::forward< P3 >( m_p3 ) , ::boost::forward< P4 >( m_p4 ) , ::boost::forward< P5 >( m_p5 ) , ::boost::forward< P6 >( m_p6 ) , ::boost::forward< P7 >( m_p7 ) , ::boost::forward< P8 >( m_p8 ) , ::boost::forward< P9 >( m_p9 )); } P0 & m_p0; P1 & m_p1; P2 & m_p2; P3 & m_p3; P4 & m_p4; P5 & m_p5; P6 & m_p6; P7 & m_p7; P8 & m_p8; P9 & m_p9; };
# 270 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp" 2



template
   < class SegmentManager
   , class T
   , bool is_iterator
   >
class named_proxy
{
   typedef typename SegmentManager::char_type char_type;
   const char_type * mp_name;
   SegmentManager * mp_mngr;
   mutable std::size_t m_num;
   const bool m_find;
   const bool m_dothrow;

   public:
   named_proxy(SegmentManager *mngr, const char_type *name, bool find, bool dothrow)
      : mp_name(name), mp_mngr(mngr), m_num(1)
      , m_find(find), m_dothrow(dothrow)
   {}



   T *operator()() const
   {
      Ctor0Arg<T> ctor_obj;
      return mp_mngr->template
         generic_construct<T>(mp_name, m_num, m_find, m_dothrow, ctor_obj);
   }
# 318 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        template< class P0> T *operator()( const P0 & p0) const { typedef Ctor1Arg <T, is_iterator, P0> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1> T *operator()( const P0 & p0 , const P1 & p1) const { typedef Ctor2Arg <T, is_iterator, P0 , P1> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2) const { typedef Ctor3Arg <T, is_iterator, P0 , P1 , P2> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3) const { typedef Ctor4Arg <T, is_iterator, P0 , P1 , P2 , P3> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3 , class P4> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4) const { typedef Ctor5Arg <T, is_iterator, P0 , P1 , P2 , P3 , P4> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5) const { typedef Ctor6Arg <T, is_iterator, P0 , P1 , P2 , P3 , P4 , P5> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6) const { typedef Ctor7Arg <T, is_iterator, P0 , P1 , P2 , P3 , P4 , P5 , P6> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7) const { typedef Ctor8Arg <T, is_iterator, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8) const { typedef Ctor9Arg <T, is_iterator, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9> T *operator()( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9) const { typedef Ctor10Arg <T, is_iterator, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9> ctor_obj_t; ctor_obj_t ctor_obj ( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 )); return mp_mngr->template generic_construct<T> (mp_name, m_num, m_find, m_dothrow, ctor_obj); }
# 319 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp" 2
# 339 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp"
   const named_proxy &operator[](std::size_t num) const
      { m_num *= num; return *this; }
};



}}}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 348 "/opt/sevenflow/boost/include/boost/interprocess/detail/named_proxy.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/cast_tags.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/cast_tags.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/detail/cast_tags.hpp" 2


namespace boost { namespace interprocess { namespace ipcdetail {

struct static_cast_tag {};
struct const_cast_tag {};
struct dynamic_cast_tag {};
struct reinterpret_cast_tag {};

}}}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/interprocess/detail/cast_tags.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 17 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/for_each_i.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/list/for_each_i.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/for.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/for.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/for.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/for.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/detail/for.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/for.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/list/for_each_i.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/tuple/to_list.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/transform.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/append.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 26 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2






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 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp"
template<std::size_t TAlign, std::size_t Align>
struct is_aligned
{
    static const bool value = (TAlign >= Align) & (TAlign % Align == 0)

         ;
};
# 180 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp"
}


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 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp"
}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 396 "/opt/sevenflow/boost/include/boost/type_traits/type_with_alignment.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/eval_if.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/eval_if.hpp"
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> { }; }

}}
# 25 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/identity.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/identity.hpp"
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> { }; }

}}
# 26 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 2

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 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp"
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 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 180 "/opt/sevenflow/boost/include/boost/aligned_storage.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp" 2






namespace boost {


template <class T>
struct has_trivial_constructor;

template <class T>
struct has_trivial_destructor;

namespace interprocess {







template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
class offset_ptr
{

   typedef offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment> self_t;
   void unspecified_bool_type_func() const {}
   typedef void (self_t::*unspecified_bool_type)() const;


   public:
   typedef PointedType element_type;
   typedef PointedType * pointer;
   typedef typename ipcdetail::
      add_reference<PointedType>::type reference;
   typedef typename ipcdetail::
      remove_volatile<typename ipcdetail::
         remove_const<PointedType>::type
            >::type value_type;
   typedef DifferenceType difference_type;
   typedef std::random_access_iterator_tag iterator_category;
   typedef OffsetType offset_type;

   public:



   offset_ptr(pointer ptr = 0) { this->set_offset(ptr); }



   template <class T>
   offset_ptr( T *ptr
             , typename ipcdetail::enable_if< ipcdetail::is_convertible<T*, PointedType*> >::type * = 0)
   { this->set_offset(static_cast<PointedType*>(ptr)); }



   offset_ptr(const offset_ptr& ptr)
   { this->set_offset(ptr.get()); }



   template<class T2, class P2, class O2, std::size_t A2>
   offset_ptr( const offset_ptr<T2, P2, O2, A2> &ptr
             , typename ipcdetail::enable_if< ipcdetail::is_convertible<T2*, PointedType*> >::type * = 0)
   { this->set_offset(static_cast<PointedType*>(ptr.get())); }



   template<class T2, class P2, class O2, std::size_t A2>
   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::static_cast_tag)
   { this->set_offset(static_cast<PointedType*>(r.get())); }



   template<class T2, class P2, class O2, std::size_t A2>
   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::const_cast_tag)
   { this->set_offset(const_cast<PointedType*>(r.get())); }



   template<class T2, class P2, class O2, std::size_t A2>
   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::dynamic_cast_tag)
   { this->set_offset(dynamic_cast<PointedType*>(r.get())); }



   template<class T2, class P2, class O2, std::size_t A2>
   offset_ptr(const offset_ptr<T2, P2, O2, A2> & r, ipcdetail::reinterpret_cast_tag)
   { this->set_offset(reinterpret_cast<PointedType*>(r.get())); }



   pointer get()const
   { return this->to_raw_pointer(); }

   offset_type get_offset() const
   { return internal.m_offset; }



   pointer operator->() const
   { return this->get(); }



   reference operator* () const
   {
      pointer p = this->get();
      reference r = *p;
      return r;
   }



   template<class T>
   reference operator[](T idx) const
   { return this->get()[idx]; }



   offset_ptr& operator= (pointer from)
   { this->set_offset(from); return *this; }



   offset_ptr& operator= (const offset_ptr & pt)
   { pointer p(pt.get()); (void)p; this->set_offset(p); return *this; }



   template<class T2, class P2, class O2, std::size_t A2>
   typename ipcdetail::enable_if<ipcdetail::is_convertible<T2*, PointedType*>, offset_ptr&>::type
      operator= (const offset_ptr<T2, P2, O2, A2> & ptr)
   { this->set_offset(static_cast<PointedType*>(ptr.get())); return *this; }



   offset_ptr &operator+= (difference_type offset)
   { this->inc_offset(offset * sizeof (PointedType)); return *this; }



   template<class T>
   offset_ptr &operator-= (T offset)
   { this->dec_offset(offset * sizeof (PointedType)); return *this; }



   offset_ptr& operator++ (void)
   { this->inc_offset(sizeof (PointedType)); return *this; }



   offset_ptr operator++ (int)
   { offset_ptr temp(*this); ++*this; return temp; }



   offset_ptr& operator-- (void)
   { this->dec_offset(sizeof (PointedType)); return *this; }



   offset_ptr operator-- (int)
   { offset_ptr temp(*this); --*this; return temp; }



   operator unspecified_bool_type() const
   { return this->get()? &self_t::unspecified_bool_type_func : 0; }



   bool operator! () const
   { return this->get() == 0; }



   template <class U>
   struct rebind
   { typedef offset_ptr<U, DifferenceType, OffsetType, OffsetAlignment> other; };



   static offset_ptr pointer_to(reference r)
   { return offset_ptr(&r); }



   friend offset_ptr operator+(difference_type diff, const offset_ptr& right)
   { offset_ptr tmp(right); tmp += diff; return tmp; }



   friend offset_ptr operator+(const offset_ptr& left, difference_type diff)
   { offset_ptr tmp(left); tmp += diff; return tmp; }



   friend offset_ptr operator-(const offset_ptr &left, difference_type diff)
   { offset_ptr tmp(left); tmp -= diff; return tmp; }



   friend offset_ptr operator-(difference_type diff, const offset_ptr &right)
   { offset_ptr tmp(right); tmp -= diff; return tmp; }



   friend difference_type operator-(const offset_ptr &pt, const offset_ptr &pt2)
   { return difference_type(pt.get()- pt2.get()); }


   friend bool operator== (const offset_ptr &pt1, const offset_ptr &pt2)
   { return pt1.get() == pt2.get(); }

   friend bool operator!= (const offset_ptr &pt1, const offset_ptr &pt2)
   { return pt1.get() != pt2.get(); }

   friend bool operator<(const offset_ptr &pt1, const offset_ptr &pt2)
   { return pt1.get() < pt2.get(); }

   friend bool operator<=(const offset_ptr &pt1, const offset_ptr &pt2)
   { return pt1.get() <= pt2.get(); }

   friend bool operator>(const offset_ptr &pt1, const offset_ptr &pt2)
   { return pt1.get() > pt2.get(); }

   friend bool operator>=(const offset_ptr &pt1, const offset_ptr &pt2)
   { return pt1.get() >= pt2.get(); }


   friend bool operator== (pointer pt1, const offset_ptr &pt2)
   { return pt1 == pt2.get(); }

   friend bool operator!= (pointer pt1, const offset_ptr &pt2)
   { return pt1 != pt2.get(); }

   friend bool operator<(pointer pt1, const offset_ptr &pt2)
   { return pt1 < pt2.get(); }

   friend bool operator<=(pointer pt1, const offset_ptr &pt2)
   { return pt1 <= pt2.get(); }

   friend bool operator>(pointer pt1, const offset_ptr &pt2)
   { return pt1 > pt2.get(); }

   friend bool operator>=(pointer pt1, const offset_ptr &pt2)
   { return pt1 >= pt2.get(); }


   friend bool operator== (const offset_ptr &pt1, pointer pt2)
   { return pt1.get() == pt2; }

   friend bool operator!= (const offset_ptr &pt1, pointer pt2)
   { return pt1.get() != pt2; }

   friend bool operator<(const offset_ptr &pt1, pointer pt2)
   { return pt1.get() < pt2; }

   friend bool operator<=(const offset_ptr &pt1, pointer pt2)
   { return pt1.get() <= pt2; }

   friend bool operator>(const offset_ptr &pt1, pointer pt2)
   { return pt1.get() > pt2; }

   friend bool operator>=(const offset_ptr &pt1, pointer pt2)
   { return pt1.get() >= pt2; }

   friend void swap(offset_ptr &left, offset_ptr &right)
   {
      pointer ptr = right.get();
      right = left;
      left = ptr;
   }

   private:
# 319 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp"
   __attribute__((__noinline__))

   void set_offset(const PointedType *ptr)
   {




      if(!ptr){
         internal.m_offset = 1;
      }
      else{
         internal.m_offset = (OffsetType)((const char*)ptr - (const char*)(this));
         ((internal.m_offset != 1) ? static_cast<void> (0) : __assert_fail ("internal.m_offset != 1", "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp", 332, __PRETTY_FUNCTION__));
      }
   }




   __attribute__((__noinline__))

   PointedType * to_raw_pointer() const
   {



      return static_cast<PointedType *>(
         static_cast<void*>(
            (internal.m_offset == 1) ?
               0 :
                  (const_cast<char*>(reinterpret_cast<const char*>(this)) + internal.m_offset)
         )
      );
   }

   void inc_offset(DifferenceType bytes)
   { internal.m_offset += bytes; }

   void dec_offset(DifferenceType bytes)
   { internal.m_offset -= bytes; }

   union internal_type{
      OffsetType m_offset;
    typename ::boost::aligned_storage
         < sizeof(OffsetType)
         , (OffsetAlignment == offset_type_alignment) ?
            ::boost::alignment_of<OffsetType>::value : OffsetAlignment
         >::type alignment_helper;
   } internal;

};



template<class E, class T, class W, class X, class Y, std::size_t Z>
inline std::basic_ostream<E, T> & operator<<
   (std::basic_ostream<E, T> & os, offset_ptr<W, X, Y, Z> const & p)
{ return os << p.get_offset(); }



template<class E, class T, class W, class X, class Y, std::size_t Z>
inline std::basic_istream<E, T> & operator>>
   (std::basic_istream<E, T> & is, offset_ptr<W, X, Y, Z> & p)
{ return is >> p.get_offset(); }


template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
   static_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
            (r, boost::interprocess::ipcdetail::static_cast_tag());
}


template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
   const_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
            (r, boost::interprocess::ipcdetail::const_cast_tag());
}


template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
   dynamic_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
            (r, boost::interprocess::ipcdetail::dynamic_cast_tag());
}


template<class T1, class P1, class O1, std::size_t A1, class T2, class P2, class O2, std::size_t A2>
inline boost::interprocess::offset_ptr<T1, P1, O1, A1>
   reinterpret_pointer_cast(const boost::interprocess::offset_ptr<T2, P2, O2, A2> & r)
{
   return boost::interprocess::offset_ptr<T1, P1, O1, A1>
            (r, boost::interprocess::ipcdetail::reinterpret_cast_tag());
}

}




template <class T, class P, class O, std::size_t A>
struct has_trivial_constructor< boost::interprocess::offset_ptr<T, P, O, A> >
{
   static const bool value = true;
};


template <class T, class P, class O, std::size_t A>
struct has_trivial_destructor< boost::interprocess::offset_ptr<T, P, O, A> >
{
   static const bool value = true;
};


namespace interprocess {



template <class T, class P, class O, std::size_t A>
inline T * to_raw_pointer(boost::interprocess::offset_ptr<T, P, O, A> const & p)
{ return p.get(); }

}



}



namespace boost{



namespace intrusive {


template<class VoidPointer, std::size_t N>
struct max_pointer_plus_bits;

template<std::size_t OffsetAlignment, class P, class O, std::size_t A>
struct max_pointer_plus_bits<boost::interprocess::offset_ptr<void, P, O, A>, OffsetAlignment>
{


   static const std::size_t value = ::boost::interprocess::ipcdetail::ls_zeros<OffsetAlignment>::value - 1;
};


template<class Pointer, std::size_t NumBits>
struct pointer_plus_bits;

template<class T, class P, class O, std::size_t A, std::size_t NumBits>
struct pointer_plus_bits<boost::interprocess::offset_ptr<T, P, O, A>, NumBits>
{
   typedef boost::interprocess::offset_ptr<T, P, O, A> pointer;


   static const std::size_t Mask = ((std::size_t(1) << NumBits)-1)<<1u;

   static pointer get_pointer(const pointer &n)
   { return reinterpret_cast<T*>(std::size_t(n.get()) & ~std::size_t(Mask)); }

   static void set_pointer(pointer &n, pointer p)
   {
      std::size_t pint = std::size_t(p.get());
      ((0 == (std::size_t(pint) & Mask)) ? static_cast<void> (0) : __assert_fail ("0 == (std::size_t(pint) & Mask)", "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp", 493, __PRETTY_FUNCTION__));
      n = reinterpret_cast<T*>(pint | (std::size_t(n.get()) & std::size_t(Mask)));
   }

   static std::size_t get_bits(const pointer &n)
   { return(std::size_t(n.get()) & std::size_t(Mask)) >> 1u; }

   static void set_bits(pointer &n, std::size_t b)
   {
      ((b < (std::size_t(1) << NumBits)) ? static_cast<void> (0) : __assert_fail ("b < (std::size_t(1) << NumBits)", "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp", 502, __PRETTY_FUNCTION__));
      n = reinterpret_cast<T*>(std::size_t(get_pointer(n).get()) | (b << 1u));
   }
};

}


template<class T, class U>
struct pointer_to_other;




template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment, class U>
struct pointer_to_other
   < ::boost::interprocess::offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment>, U >
{
   typedef ::boost::interprocess::offset_ptr<U, DifferenceType, OffsetType, OffsetAlignment> type;
};

}


# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 527 "/opt/sevenflow/boost/include/boost/interprocess/offset_ptr.hpp" 2
# 31 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/indexes/iset_index.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/indexes/iset_index.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/indexes/iset_index.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/intrusive_fwd.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/intrusive_fwd.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 17 "/opt/sevenflow/boost/include/boost/intrusive/intrusive_fwd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/link_mode.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/link_mode.hpp"
namespace boost {
namespace intrusive {



enum link_mode_type{





   normal_link,






   safe_link,






   auto_unlink
};
}
}
# 18 "/opt/sevenflow/boost/include/boost/intrusive/intrusive_fwd.hpp" 2




namespace boost {

namespace intrusive {

struct none;

}
}

namespace boost {
namespace intrusive {






template<class NodeTraits>
class circular_list_algorithms;

template<class NodeTraits>
class circular_slist_algorithms;

template<class NodeTraits>
class rbtree_algorithms;







template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   , class O5 = none
   >



class slist;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class slist_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class slist_member_hook;



template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   >



class list;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class list_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class list_member_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class list_hook;



template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class rbtree;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class set;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class multiset;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class set_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class set_member_hook;



template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class splaytree;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class splay_set;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class splay_multiset;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class splay_set_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class splay_set_member_hook;



template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class avltree;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class avl_set;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class avl_multiset;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class avl_set_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class avl_set_member_hook;




template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class treap;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class treap_set;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class treap_multiset;


template <class T>
struct priority_compare;



template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class sgtree;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class sg_set;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class sg_multiset;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class bs_set_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class bs_set_member_hook;




template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   , class O5 = none
   , class O6 = none
   , class O7 = none
   , class O8 = none
   , class O9 = none
   , class O10 = none
   >



class hashtable;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   , class O5 = none
   , class O6 = none
   , class O7 = none
   , class O8 = none
   , class O9 = none
   , class O10 = none
   >



class unordered_set;


template
   < class T
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   , class O5 = none
   , class O6 = none
   , class O7 = none
   , class O8 = none
   , class O9 = none
   , class O10 = none
   >



class unordered_multiset;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class unordered_set_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   >



class unordered_set_member_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class any_base_hook;


template
   < class O1 = none
   , class O2 = none
   , class O3 = none
   >



class any_member_hook;

}
}
# 18 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 18 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/assert.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/intrusive/detail/assert.hpp"
# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/intrusive/detail/assert.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/intrusive/detail/assert.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/intrusive/detail/assert.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp" 2







namespace boost {
namespace intrusive {
namespace detail {

template<class Parent, class Member>
inline std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
{
# 44 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp"
   const Parent * const parent = 0;
   const char *const member = static_cast<const char*>(static_cast<const void*>(&(parent->*ptr_to_member)));
   return std::ptrdiff_t(member - static_cast<const char*>(static_cast<const void*>(parent)));
# 57 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp"
}

template<class Parent, class Member>
inline Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
{
   return static_cast<Parent*>
      (
         static_cast<void*>
         (
            static_cast<char*>(static_cast<void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
         )
      );
}

template<class Parent, class Member>
inline const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
{
   return static_cast<const Parent*>
      (
         static_cast<const void*>
         (
            static_cast<const char*>(static_cast<const void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
         )
      );
}

}
}
}





# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 92 "/opt/sevenflow/boost/include/boost/intrusive/detail/parent_from_member.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/ebo_functor_holder.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/ebo_functor_holder.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/ebo_functor_holder.hpp" 2


namespace boost {
namespace intrusive {
namespace detail {

template<typename T, bool IsEmpty = true>
class ebo_functor_holder_impl
{
   public:
   ebo_functor_holder_impl()
   {}
   ebo_functor_holder_impl(const T& t)
      : t_(t)
   {}
   template<class Arg1, class Arg2>
   ebo_functor_holder_impl(const Arg1& arg1, const Arg2& arg2)
      : t_(arg1, arg2)
   {}

   T& get(){return t_;}
   const T& get()const{return t_;}

   private:
   T t_;
};

template<typename T>
class ebo_functor_holder_impl<T, false>
   : public T
{
   public:
   ebo_functor_holder_impl()
   {}
   ebo_functor_holder_impl(const T& t)
      : T(t)
   {}
   template<class Arg1, class Arg2>
   ebo_functor_holder_impl(const Arg1& arg1, const Arg2& arg2)
      : T(arg1, arg2)
   {}

   T& get(){return *this;}
   const T& get()const{return *this;}
};

template<typename T>
class ebo_functor_holder
   : public ebo_functor_holder_impl<T, is_unary_or_binary_function<T>::value>
{
   private:
   typedef ebo_functor_holder_impl<T, is_unary_or_binary_function<T>::value> super;

   public:
   ebo_functor_holder(){}
   ebo_functor_holder(const T& t)
      : super(t)
   {}

   template<class Arg1, class Arg2>
   ebo_functor_holder(const Arg1& arg1, const Arg2& arg2)
      : super(arg1, arg2)
   {}

   ebo_functor_holder& operator=(const ebo_functor_holder& x)
   {
      this->get()=x.get();
      return *this;
   }
};


}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 94 "/opt/sevenflow/boost/include/boost/intrusive/detail/ebo_functor_holder.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/function_detector.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/intrusive/detail/function_detector.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/intrusive/detail/function_detector.hpp" 2

namespace boost {
namespace intrusive {
namespace function_detector {

    typedef char NotFoundType;
    struct StaticFunctionType { NotFoundType x [2]; };
    struct NonStaticFunctionType { NotFoundType x [3]; };

    enum
         { NotFound = 0,
           StaticFunction = sizeof( StaticFunctionType ) - sizeof( NotFoundType ),
           NonStaticFunction = sizeof( NonStaticFunctionType ) - sizeof( NotFoundType )
         };

}
}
}
# 86 "/opt/sevenflow/boost/include/boost/intrusive/detail/function_detector.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 87 "/opt/sevenflow/boost/include/boost/intrusive/detail/function_detector.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 2

namespace boost { namespace intrusive { namespace function_detector { template < class T, class NonStaticType, class NonStaticConstType, class StaticType > class DetectMember_InstantiationKey_to_node_ptr { template < NonStaticType > struct TestNonStaticNonConst ; template < NonStaticConstType > struct TestNonStaticConst ; template < StaticType > struct TestStatic ; template <class U > static NonStaticFunctionType Test( TestNonStaticNonConst<&U::to_node_ptr>*, int ); template <class U > static NonStaticFunctionType Test( TestNonStaticConst<&U::to_node_ptr>*, int ); template <class U> static StaticFunctionType Test( TestStatic<&U::to_node_ptr>*, int ); template <class U> static NotFoundType Test( ... ); public : static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType)); };}}}
namespace boost { namespace intrusive { namespace function_detector { template < class T, class NonStaticType, class NonStaticConstType, class StaticType > class DetectMember_InstantiationKey_to_value_ptr { template < NonStaticType > struct TestNonStaticNonConst ; template < NonStaticConstType > struct TestNonStaticConst ; template < StaticType > struct TestStatic ; template <class U > static NonStaticFunctionType Test( TestNonStaticNonConst<&U::to_value_ptr>*, int ); template <class U > static NonStaticFunctionType Test( TestNonStaticConst<&U::to_value_ptr>*, int ); template <class U> static StaticFunctionType Test( TestStatic<&U::to_value_ptr>*, int ); template <class U> static NotFoundType Test( ... ); public : static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType)); };}}}

namespace boost {
namespace intrusive {
namespace detail {

template<class ValueTraits>
struct is_stateful_value_traits
{
   typedef typename ValueTraits::node_ptr node_ptr;
   typedef typename ValueTraits::pointer pointer;
   typedef typename ValueTraits::value_type value_type;
   typedef typename ValueTraits::const_node_ptr const_node_ptr;
   typedef typename ValueTraits::const_pointer const_pointer;

   typedef ValueTraits value_traits;

   static const bool value =
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_node_ptr< ValueTraits, node_ptr (ValueTraits::*)(value_type&), node_ptr (ValueTraits::*)(value_type&) const, node_ptr (*)(value_type&) >::check))
      ||
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_value_ptr< ValueTraits, pointer (ValueTraits::*)(node_ptr), pointer (ValueTraits::*)(node_ptr) const, pointer (*)(node_ptr) >::check))
      ||
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_node_ptr< ValueTraits, const_node_ptr (ValueTraits::*)(const value_type&), const_node_ptr (ValueTraits::*)(const value_type&) const, const_node_ptr (*)(const value_type&) >::check))
      ||
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_value_ptr< ValueTraits, const_pointer (ValueTraits::*)(const_node_ptr), const_pointer (ValueTraits::*)(const_node_ptr) const, const_pointer (*)(const_node_ptr) >::check))
      ;
};

}}}



# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 76 "/opt/sevenflow/boost/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 57 "/opt/sevenflow/boost/include/boost/cstdint.hpp"
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdint.h" 1 3 4
# 9 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdint.h" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 27 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/stdint.h" 2 3 4
# 48 "/usr/include/stdint.h" 3 4
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;

typedef unsigned int uint32_t;



typedef unsigned long int uint64_t;
# 65 "/usr/include/stdint.h" 3 4
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;

typedef long int int_least64_t;






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

typedef unsigned long int uint_least64_t;
# 90 "/usr/include/stdint.h" 3 4
typedef signed char int_fast8_t;

typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 103 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;

typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 122 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 134 "/usr/include/stdint.h" 3 4
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
# 10 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stdint.h" 2 3 4
# 58 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 2
# 100 "/opt/sevenflow/boost/include/boost/cstdint.hpp"
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;

}
# 26 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 27 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2
# 1 "/usr/include/c++/4.8.2/climits" 1 3
# 39 "/usr/include/c++/4.8.2/climits" 3
       
# 40 "/usr/include/c++/4.8.2/climits" 3

# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/climits" 2 3
# 28 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 30 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2


namespace boost {
namespace intrusive {
namespace detail {

template <class T>
struct internal_member_value_traits
{
   template <class U> static detail::one test(...);
   template <class U> static detail::two test(typename U::member_value_traits* = 0);
   static const bool value = sizeof(test<T>(0)) == sizeof(detail::two);
};

template <class T>
struct internal_base_hook_bool
{
   template<bool Add>
   struct two_or_three {one _[2 + Add];};
   template <class U> static one test(...);
   template <class U> static two_or_three<U::boost_intrusive_tags::is_base_hook> test (int);
   static const std::size_t value = sizeof(test<T>(0));
};

template <class T>
struct internal_base_hook_bool_is_true
{
   static const bool value = internal_base_hook_bool<T>::value > sizeof(one)*2;
};

template <class T>
struct internal_any_hook_bool
{
   template<bool Add>
   struct two_or_three {one _[2 + Add];};
   template <class U> static one test(...);
   template <class U> static two_or_three<U::is_any_hook> test (int);
   static const std::size_t value = sizeof(test<T>(0));
};

template <class T>
struct internal_any_hook_bool_is_true
{
   static const bool value = internal_any_hook_bool<T>::value > sizeof(one)*2;
};


template <class T>
struct external_value_traits_bool
{
   template<bool Add>
   struct two_or_three {one _[2 + Add];};
   template <class U> static one test(...);
   template <class U> static two_or_three<U::external_value_traits> test (int);
   static const std::size_t value = sizeof(test<T>(0));
};

template <class T>
struct external_bucket_traits_bool
{
   template<bool Add>
   struct two_or_three {one _[2 + Add];};
   template <class U> static one test(...);
   template <class U> static two_or_three<U::external_bucket_traits> test (int);
   static const std::size_t value = sizeof(test<T>(0));
};

template <class T>
struct external_value_traits_is_true
{
   static const bool value = external_value_traits_bool<T>::value > sizeof(one)*2;
};

template<class Node, class Tag, link_mode_type LinkMode, int>
struct node_holder
   : public Node
{};

template <class T>
inline T* to_raw_pointer(T* p)
{ return p; }

template <class Pointer>
inline typename boost::intrusive::pointer_traits<Pointer>::element_type*
to_raw_pointer(const Pointer &p)
{ return boost::intrusive::detail::to_raw_pointer(p.operator->()); }



template<class ConstReference>
class equal_to_value
{
   ConstReference t_;

   public:
   equal_to_value(ConstReference t)
      : t_(t)
   {}

   bool operator()(ConstReference t)const
   { return t_ == t; }
};

class null_disposer
{
   public:
   template <class Pointer>
   void operator()(Pointer)
   {}
};

template<class NodeAlgorithms>
class init_disposer
{
   typedef typename NodeAlgorithms::node_ptr node_ptr;

   public:
   void operator()(const node_ptr & p)
   { NodeAlgorithms::init(p); }
};

template<bool ConstantSize, class SizeType>
struct size_holder
{
   static const bool constant_time_size = ConstantSize;
   typedef SizeType size_type;

   SizeType get_size() const
   { return size_; }

   void set_size(SizeType size)
   { size_ = size; }

   void decrement()
   { --size_; }

   void increment()
   { ++size_; }

   SizeType size_;
};

template<class SizeType>
struct size_holder<false, SizeType>
{
   static const bool constant_time_size = false;
   typedef SizeType size_type;

   size_type get_size() const
   { return 0; }

   void set_size(size_type)
   {}

   void decrement()
   {}

   void increment()
   {}
};

template<class KeyValueCompare, class Container>
struct key_nodeptr_comp
   : private detail::ebo_functor_holder<KeyValueCompare>
{
   typedef typename Container::real_value_traits real_value_traits;
   typedef typename Container::value_type value_type;
   typedef typename real_value_traits::node_ptr node_ptr;
   typedef typename real_value_traits::const_node_ptr const_node_ptr;
   typedef detail::ebo_functor_holder<KeyValueCompare> base_t;
   key_nodeptr_comp(KeyValueCompare kcomp, const Container *cont)
      : base_t(kcomp), cont_(cont)
   {}

   template<class T>
   struct is_node_ptr
   {
      static const bool value = is_same<T, const_node_ptr>::value || is_same<T, node_ptr>::value;
   };

   template<class T>
   const value_type & key_forward
      (const T &node, typename enable_if_c<is_node_ptr<T>::value>::type * = 0) const
   { return *cont_->get_real_value_traits().to_value_ptr(node); }

   template<class T>
   const T & key_forward(const T &key, typename enable_if_c<!is_node_ptr<T>::value>::type* = 0) const
   { return key; }


   template<class KeyType, class KeyType2>
   bool operator()(const KeyType &key1, const KeyType2 &key2) const
   { return base_t::get()(this->key_forward(key1), this->key_forward(key2)); }

   const Container *cont_;
};

template<class F, class Container>
struct node_cloner
   : private detail::ebo_functor_holder<F>
{
   typedef typename Container::real_value_traits real_value_traits;
   typedef typename Container::node_algorithms node_algorithms;
   typedef typename real_value_traits::value_type value_type;
   typedef typename real_value_traits::pointer pointer;
   typedef typename real_value_traits::node_traits::node node;
   typedef typename real_value_traits::node_ptr node_ptr;
   typedef typename real_value_traits::const_node_ptr const_node_ptr;
   typedef detail::ebo_functor_holder<F> base_t;
   enum { safemode_or_autounlink =
            (int)real_value_traits::link_mode == (int)auto_unlink ||
            (int)real_value_traits::link_mode == (int)safe_link };

   node_cloner(F f, const Container *cont)
      : base_t(f), cont_(cont)
   {}

   node_ptr operator()(const node_ptr & p)
   { return this->operator()(*p); }

   node_ptr operator()(const node &to_clone)
   {
      const value_type &v =
         *cont_->get_real_value_traits().to_value_ptr
            (pointer_traits<const_node_ptr>::pointer_to(to_clone));
      node_ptr n = cont_->get_real_value_traits().to_node_ptr(*base_t::get()(v));

      if(safemode_or_autounlink)
         ((node_algorithms::unique(n)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(n)", "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp", 258, __PRETTY_FUNCTION__));
      return n;
   }

   const Container *cont_;
};

template<class F, class Container>
struct node_disposer
   : private detail::ebo_functor_holder<F>
{
   typedef typename Container::real_value_traits real_value_traits;
   typedef typename real_value_traits::node_ptr node_ptr;
   typedef detail::ebo_functor_holder<F> base_t;
   typedef typename Container::node_algorithms node_algorithms;
   enum { safemode_or_autounlink =
            (int)real_value_traits::link_mode == (int)auto_unlink ||
            (int)real_value_traits::link_mode == (int)safe_link };

   node_disposer(F f, const Container *cont)
      : base_t(f), cont_(cont)
   {}

   void operator()(const node_ptr & p)
   {
      if(safemode_or_autounlink)
         node_algorithms::init(p);
      base_t::get()(cont_->get_real_value_traits().to_value_ptr(p));
   }
   const Container *cont_;
};

struct dummy_constptr
{
   dummy_constptr(const void *)
   {}

   const void *get_ptr() const
   { return 0; }
};

template<class VoidPointer>
struct constptr
{
   typedef typename boost::intrusive::pointer_traits<VoidPointer>::
      template rebind_pointer<const void>::type ConstVoidPtr;

   constptr(const void *ptr)
      : const_void_ptr_(ptr)
   {}

   const void *get_ptr() const
   { return boost::intrusive::detail::to_raw_pointer(const_void_ptr_); }

   ConstVoidPtr const_void_ptr_;
};

template <class VoidPointer, bool store_ptr>
struct select_constptr
{
   typedef typename detail::if_c
      < store_ptr
      , constptr<VoidPointer>
      , dummy_constptr
      >::type type;
};

template<class T, bool Add>
struct add_const_if_c
{
   typedef typename detail::if_c
      < Add
      , typename detail::add_const<T>::type
      , T
      >::type type;
};

template <link_mode_type LinkMode>
struct link_dispatch
{};

template<class Hook>
void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
{


   (void)hook; ((!hook.is_linked()) ? static_cast<void> (0) : __assert_fail ("!hook.is_linked()", "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp", 344, __PRETTY_FUNCTION__));
}

template<class Hook>
void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
{ hook.unlink(); }

template<class Hook>
void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
{}

template<class T, class NodeTraits, link_mode_type LinkMode, class Tag, int HookType>
struct base_hook_traits
{
   public:
   typedef detail::node_holder
      <typename NodeTraits::node, Tag, LinkMode, HookType> node_holder;
   typedef typename NodeTraits::node node;
   typedef NodeTraits node_traits;
   typedef T value_type;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<T>::type pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const T>::type const_pointer;


   typedef T & reference;
   typedef const T & const_reference;
   typedef node_holder & node_holder_reference;
   typedef const node_holder & const_node_holder_reference;
   typedef node& node_reference;
   typedef const node & const_node_reference;

   static const link_mode_type link_mode = LinkMode;

   static pointer to_value_ptr(const node_ptr & n)
   {
      return pointer_traits<pointer>::pointer_to
         (static_cast<reference>(static_cast<node_holder_reference>(*n)));
   }

   static const_pointer to_value_ptr(const const_node_ptr & n)
   {
      return pointer_traits<const_pointer>::pointer_to
         (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
   }

   static node_ptr to_node_ptr(reference value)
   {
      return pointer_traits<node_ptr>::pointer_to
         (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
   }

   static const_node_ptr to_node_ptr(const_reference value)
   {
      return pointer_traits<const_node_ptr>::pointer_to
         (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
   }
};

template<class T, class Hook, Hook T::* P>
struct member_hook_traits
{
   public:
   typedef Hook hook_type;
   typedef typename hook_type::boost_intrusive_tags::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef T value_type;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<T>::type pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const T>::type const_pointer;
   typedef T & reference;
   typedef const T & const_reference;
   typedef node& node_reference;
   typedef const node & const_node_reference;
   typedef hook_type& hook_reference;
   typedef const hook_type & const_hook_reference;

   static const link_mode_type link_mode = Hook::boost_intrusive_tags::link_mode;

   static node_ptr to_node_ptr(reference value)
   {
      return pointer_traits<node_ptr>::pointer_to
         (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
   }

   static const_node_ptr to_node_ptr(const_reference value)
   {
      return pointer_traits<const_node_ptr>::pointer_to
         (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
   }

   static pointer to_value_ptr(const node_ptr & n)
   {
      return pointer_traits<pointer>::pointer_to
         (*detail::parent_from_member<T, Hook>
            (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
   }

   static const_pointer to_value_ptr(const const_node_ptr & n)
   {
      return pointer_traits<const_pointer>::pointer_to
         (*detail::parent_from_member<T, Hook>
            (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
   }
};

template<class Functor>
struct function_hook_traits
{
   public:
   typedef typename Functor::hook_type hook_type;
   typedef typename Functor::hook_ptr hook_ptr;
   typedef typename Functor::const_hook_ptr const_hook_ptr;
   typedef typename hook_type::boost_intrusive_tags::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename Functor::value_type value_type;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<value_type>::type pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const value_type>::type const_pointer;
   typedef value_type & reference;
   typedef const value_type & const_reference;
   static const link_mode_type link_mode = hook_type::boost_intrusive_tags::link_mode;

   static node_ptr to_node_ptr(reference value)
   { return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value))); }

   static const_node_ptr to_node_ptr(const_reference value)
   { return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value))); }

   static pointer to_value_ptr(const node_ptr & n)
   { return Functor::to_value_ptr(to_hook_ptr(n)); }

   static const_pointer to_value_ptr(const const_node_ptr & n)
   { return Functor::to_value_ptr(to_hook_ptr(n)); }

   private:
   static hook_ptr to_hook_ptr(const node_ptr & n)
   { return hook_ptr(&*static_cast<hook_type*>(&*n)); }

   static const_hook_ptr to_hook_ptr(const const_node_ptr & n)
   { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); }
};




inline std::size_t floor_log2 (std::size_t x)
{
   const std::size_t Bits = sizeof(std::size_t)*8;
   const bool Size_t_Bits_Power_2= !(Bits & (Bits-1));
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Size_t_Bits_Power_2) == 0 ? false : true) >)> boost_static_assert_typedef_503;

   std::size_t n = x;
   std::size_t log2 = 0;

   for(std::size_t shift = Bits >> 1; shift; shift >>= 1){
      std::size_t tmp = n >> shift;
      if (tmp)
         log2 += shift, n = tmp;
   }

   return log2;
}

inline float fast_log2 (float val)
{
   union caster_t
   {
      boost::uint32_t x;
      float val;
   } caster;

   caster.val = val;
   boost::uint32_t x = caster.x;
   const int log_2 = (int)(((x >> 23) & 255) - 128);
   x &= ~(255 << 23);
   x += 127 << 23;
   caster.x = x;
   val = caster.val;
   val = ((-1.0f/3.f) * val + 2.f) * val - (2.0f/3.f);

   return (val + log_2);
}

inline std::size_t ceil_log2 (std::size_t x)
{
   return ((x & (x-1))!= 0) + floor_log2(x);
}

template<class SizeType, std::size_t N>
struct numbits_eq
{
   static const bool value = sizeof(SizeType)*8 == N;
};

template<class SizeType, class Enabler = void >
struct sqrt2_pow_max;

template <class SizeType>
struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 32> >::type>
{
   static const boost::uint32_t value = 0xb504f334;
   static const std::size_t pow = 31;
};

template <class SizeType>
struct sqrt2_pow_max<SizeType, typename enable_if< numbits_eq<SizeType, 64> >::type>
{
   static const boost::uint64_t value = 0xb504f333f9de6484ull;
   static const std::size_t pow = 63;
};



inline std::size_t sqrt2_pow_2xplus1 (std::size_t x)
{
   const std::size_t value = (std::size_t)sqrt2_pow_max<std::size_t>::value;
   const std::size_t pow = (std::size_t)sqrt2_pow_max<std::size_t>::pow;
   return (value >> (pow - x)) + 1;
}

template<class Container, class Disposer>
class exception_disposer
{
   Container *cont_;
   Disposer &disp_;

   exception_disposer(const exception_disposer&);
   exception_disposer &operator=(const exception_disposer&);

   public:
   exception_disposer(Container &cont, Disposer &disp)
      : cont_(&cont), disp_(disp)
   {}

   void release()
   { cont_ = 0; }

   ~exception_disposer()
   {
      if(cont_){
         cont_->clear_and_dispose(disp_);
      }
   }
};

template<class Container, class Disposer, class SizeType>
class exception_array_disposer
{
   Container *cont_;
   Disposer &disp_;
   SizeType &constructed_;

   exception_array_disposer(const exception_array_disposer&);
   exception_array_disposer &operator=(const exception_array_disposer&);

   public:

   exception_array_disposer
      (Container &cont, Disposer &disp, SizeType &constructed)
      : cont_(&cont), disp_(disp), constructed_(constructed)
   {}

   void release()
   { cont_ = 0; }

   ~exception_array_disposer()
   {
      SizeType n = constructed_;
      if(cont_){
         while(n--){
            cont_[n].clear_and_dispose(disp_);
         }
      }
   }
};

template<class ValueTraits, bool ExternalValueTraits>
struct store_cont_ptr_on_it_impl
{
   static const bool value = is_stateful_value_traits<ValueTraits>::value;
};

template<class ValueTraits>
struct store_cont_ptr_on_it_impl<ValueTraits, true>
{
   static const bool value = true;
};

template <class Container>
struct store_cont_ptr_on_it
{
   typedef typename Container::value_traits value_traits;
   static const bool value = store_cont_ptr_on_it_impl
      <value_traits, external_value_traits_is_true<value_traits>::value>::value;
};

template<class Container, bool IsConst>
struct node_to_value
   : public detail::select_constptr
      < typename pointer_traits
            <typename Container::pointer>::template rebind_pointer<void>::type
      , detail::store_cont_ptr_on_it<Container>::value
      >::type
{
   static const bool store_container_ptr =
      detail::store_cont_ptr_on_it<Container>::value;

   typedef typename Container::real_value_traits real_value_traits;
   typedef typename real_value_traits::value_type value_type;
   typedef typename detail::select_constptr
      < typename pointer_traits
            <typename Container::pointer>::template rebind_pointer<void>::type
      , store_container_ptr >::type Base;
   typedef typename real_value_traits::node_traits::node node;
   typedef typename detail::add_const_if_c
         <value_type, IsConst>::type vtype;
   typedef typename detail::add_const_if_c
         <node, IsConst>::type ntype;
   typedef typename pointer_traits
      <typename Container::pointer>::template rebind_pointer<ntype>::type npointer;

   node_to_value(const Container *cont)
      : Base(cont)
   {}

   typedef vtype & result_type;
   typedef ntype & first_argument_type;

   const Container *get_container() const
   {
      if(store_container_ptr)
         return static_cast<const Container*>(Base::get_ptr());
      else
         return 0;
   }

   const real_value_traits *get_real_value_traits() const
   {
      if(store_container_ptr)
         return &this->get_container()->get_real_value_traits();
      else
         return 0;
   }

   result_type operator()(first_argument_type arg) const
   {
      return *(this->get_real_value_traits()->to_value_ptr
         (pointer_traits<npointer>::pointer_to(arg)));
   }
};


union max_align
{
   char char_;
   short short_;
   int int_;
   long long_;

   long long long_long_;

   float float_;
   double double_;
   long double long_double_;
   void * void_ptr_;
};

template<class T, std::size_t N>
class array_initializer
{
   public:
   template<class CommonInitializer>
   array_initializer(const CommonInitializer &init)
   {
      char *init_buf = (char*)rawbuf;
      std::size_t i = 0;
      try{
         for(; i != N; ++i){
            new(init_buf)T(init);
            init_buf += sizeof(T);
         }
      }
      catch(...){
         while(i--){
            init_buf -= sizeof(T);
            ((T*)init_buf)->~T();
         }
         throw;
      }
   }

   operator T* ()
   { return (T*)(rawbuf); }

   operator const T*() const
   { return (const T*)(rawbuf); }

   ~array_initializer()
   {
      char *init_buf = (char*)rawbuf + N*sizeof(T);
      for(std::size_t i = 0; i != N; ++i){
         init_buf -= sizeof(T);
         ((T*)init_buf)->~T();
      }
   }

   private:
   detail::max_align rawbuf[(N*sizeof(T)-1)/sizeof(detail::max_align)+1];
};




template<class It>
class reverse_iterator
 : public std::iterator<
  typename std::iterator_traits<It>::iterator_category,
  typename std::iterator_traits<It>::value_type,
  typename std::iterator_traits<It>::difference_type,
  typename std::iterator_traits<It>::pointer,
  typename std::iterator_traits<It>::reference>
{
   public:
 typedef typename std::iterator_traits<It>::pointer pointer;
 typedef typename std::iterator_traits<It>::reference reference;
  typedef typename std::iterator_traits<It>::difference_type difference_type;
 typedef It iterator_type;

 reverse_iterator(){}

 explicit reverse_iterator(It r)
  : m_current(r)
   {}

 template<class OtherIt>
 reverse_iterator(const reverse_iterator<OtherIt>& r)
    : m_current(r.base())
 {}

 It base() const
   { return m_current; }

 reference operator*() const
   { It temp(m_current); --temp; return *temp; }

 pointer operator->() const
   { It temp(m_current); --temp; return temp.operator->(); }

 reference operator[](difference_type off) const
 { return this->m_current[-off]; }

 reverse_iterator& operator++()
   { --m_current; return *this; }

 reverse_iterator operator++(int)
 {
  reverse_iterator temp = *this;
  --m_current;
  return temp;
 }

 reverse_iterator& operator--()
 {
    ++m_current;
  return *this;
   }

 reverse_iterator operator--(int)
 {
    reverse_iterator temp(*this);
    ++m_current;
    return temp;
 }

 friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
 { return l.m_current == r.m_current; }

 friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
 { return l.m_current != r.m_current; }

 friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
 { return l.m_current < r.m_current; }

 friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
 { return l.m_current <= r.m_current; }

 friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
 { return l.m_current > r.m_current; }

 friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
 { return l.m_current >= r.m_current; }

 reverse_iterator& operator+=(difference_type off)
 { m_current -= off; return *this; }

 friend reverse_iterator operator+(const reverse_iterator & l, difference_type off)
 {
      reverse_iterator tmp(l.m_current);
      tmp.m_current -= off;
      return tmp;
   }

 reverse_iterator& operator-=(difference_type off)
 { m_current += off; return *this; }

 friend reverse_iterator operator-(const reverse_iterator & l, difference_type off)
 {
      reverse_iterator tmp(l.m_current);
      tmp.m_current += off;
      return tmp;
   }

 friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
 { return r.m_current - l.m_current; }

   private:
 It m_current;
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 878 "/opt/sevenflow/boost/include/boost/intrusive/detail/utilities.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp" 1
# 51 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 52 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 54 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp" 2



namespace boost {
namespace intrusive {
namespace detail {
# 95 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
template<class NodeTraits>
class tree_algorithms
{
   public:
   typedef typename NodeTraits::node node;
   typedef NodeTraits node_traits;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;


   struct insert_commit_data
   {
      insert_commit_data()
         : link_left(false)
         , node()
      {}
      bool link_left;
      node_ptr node;
   };

   struct nop_erase_fixup
   {
      void operator()(const node_ptr&, const node_ptr&){}
   };


   private:
   template<class Disposer>
   struct dispose_subtree_disposer
   {
      dispose_subtree_disposer(Disposer &disp, const node_ptr & subtree)
         : disposer_(&disp), subtree_(subtree)
      {}

      void release()
      { disposer_ = 0; }

      ~dispose_subtree_disposer()
      {
         if(disposer_){
            dispose_subtree(subtree_, *disposer_);
         }
      }
      Disposer *disposer_;
      node_ptr subtree_;
   };

   static node_ptr uncast(const const_node_ptr & ptr)
   { return pointer_traits<node_ptr>::const_cast_from(ptr); }



   public:
   static node_ptr begin_node(const const_node_ptr & header)
   { return node_traits::get_left(header); }

   static node_ptr end_node(const const_node_ptr & header)
   { return uncast(header); }
# 162 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static bool unique(const const_node_ptr & node)
   { return !NodeTraits::get_parent(node); }

   static node_ptr get_header(const const_node_ptr & node)
   {
      node_ptr h = uncast(node);
      if(NodeTraits::get_parent(node)){
         h = NodeTraits::get_parent(node);
         while(!is_header(h))
            h = NodeTraits::get_parent(h);
      }
      return h;
   }
# 191 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
   {
      if(node1 == node2)
         return;

      node_ptr header1(get_header(node1)), header2(get_header(node2));
      swap_nodes(node1, header1, node2, header2);
   }
# 215 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
   {
      if(node1 == node2)
         return;



      if(header1 != header2){

         if(node1 == NodeTraits::get_left(header1)){
            NodeTraits::set_left(header1, node2);
         }

         if(node1 == NodeTraits::get_right(header1)){
            NodeTraits::set_right(header1, node2);
         }

         if(node1 == NodeTraits::get_parent(header1)){
            NodeTraits::set_parent(header1, node2);
         }


         if(node2 == NodeTraits::get_left(header2)){
            NodeTraits::set_left(header2, node1);
         }

         if(node2 == NodeTraits::get_right(header2)){
            NodeTraits::set_right(header2, node1);
         }

         if(node2 == NodeTraits::get_parent(header2)){
            NodeTraits::set_parent(header2, node1);
         }
      }
      else{


         if(node1 == NodeTraits::get_left(header1)){
            NodeTraits::set_left(header1, node2);
         }
         else if(node2 == NodeTraits::get_left(header2)){
            NodeTraits::set_left(header2, node1);
         }

         if(node1 == NodeTraits::get_right(header1)){
            NodeTraits::set_right(header1, node2);
         }
         else if(node2 == NodeTraits::get_right(header2)){
            NodeTraits::set_right(header2, node1);
         }

         if(node1 == NodeTraits::get_parent(header1)){
            NodeTraits::set_parent(header1, node2);
         }
         else if(node2 == NodeTraits::get_parent(header2)){
            NodeTraits::set_parent(header2, node1);
         }



         if(node1 == NodeTraits::get_parent(node2)){
            NodeTraits::set_parent(node2, node2);

            if(node2 == NodeTraits::get_right(node1)){
               NodeTraits::set_right(node1, node1);
            }
            else{
               NodeTraits::set_left(node1, node1);
            }
         }
         else if(node2 == NodeTraits::get_parent(node1)){
            NodeTraits::set_parent(node1, node1);

            if(node1 == NodeTraits::get_right(node2)){
               NodeTraits::set_right(node2, node2);
            }
            else{
               NodeTraits::set_left(node2, node2);
            }
         }
      }


      node_ptr temp;

      temp = NodeTraits::get_left(node1);
      NodeTraits::set_left(node1, NodeTraits::get_left(node2));
      NodeTraits::set_left(node2, temp);

      temp = NodeTraits::get_right(node1);
      NodeTraits::set_right(node1, NodeTraits::get_right(node2));
      NodeTraits::set_right(node2, temp);

      temp = NodeTraits::get_parent(node1);
      NodeTraits::set_parent(node1, NodeTraits::get_parent(node2));
      NodeTraits::set_parent(node2, temp);


      if((temp = NodeTraits::get_left(node1))){
         NodeTraits::set_parent(temp, node1);
      }
      if((temp = NodeTraits::get_right(node1))){
         NodeTraits::set_parent(temp, node1);
      }
      if((temp = NodeTraits::get_parent(node1)) &&

         temp != header2){
         if(NodeTraits::get_left(temp) == node2){
            NodeTraits::set_left(temp, node1);
         }
         if(NodeTraits::get_right(temp) == node2){
            NodeTraits::set_right(temp, node1);
         }
      }

      if((temp = NodeTraits::get_left(node2))){
         NodeTraits::set_parent(temp, node2);
      }
      if((temp = NodeTraits::get_right(node2))){
         NodeTraits::set_parent(temp, node2);
      }
      if((temp = NodeTraits::get_parent(node2)) &&

         temp != header1){
         if(NodeTraits::get_left(temp) == node1){
            NodeTraits::set_left(temp, node2);
         }
         if(NodeTraits::get_right(temp) == node1){
            NodeTraits::set_right(temp, node2);
         }
      }
   }
# 364 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;
      replace_node(node_to_be_replaced, get_header(node_to_be_replaced), new_node);
   }
# 387 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;


      if(node_to_be_replaced == NodeTraits::get_left(header)){
         NodeTraits::set_left(header, new_node);
      }

      if(node_to_be_replaced == NodeTraits::get_right(header)){
         NodeTraits::set_right(header, new_node);
      }

      if(node_to_be_replaced == NodeTraits::get_parent(header)){
         NodeTraits::set_parent(header, new_node);
      }


      node_ptr temp;
      NodeTraits::set_left(new_node, NodeTraits::get_left(node_to_be_replaced));
      NodeTraits::set_right(new_node, NodeTraits::get_right(node_to_be_replaced));
      NodeTraits::set_parent(new_node, NodeTraits::get_parent(node_to_be_replaced));


      if((temp = NodeTraits::get_left(new_node))){
         NodeTraits::set_parent(temp, new_node);
      }
      if((temp = NodeTraits::get_right(new_node))){
         NodeTraits::set_parent(temp, new_node);
      }
      if((temp = NodeTraits::get_parent(new_node)) &&

         temp != header){
         if(NodeTraits::get_left(temp) == node_to_be_replaced){
            NodeTraits::set_left(temp, new_node);
         }
         if(NodeTraits::get_right(temp) == node_to_be_replaced){
            NodeTraits::set_right(temp, new_node);
         }
      }
   }
# 437 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static node_ptr next_node(const node_ptr & node)
   {
      node_ptr p_right(NodeTraits::get_right(node));
      if(p_right){
         return minimum(p_right);
      }
      else {
         node_ptr p(node);
         node_ptr x = NodeTraits::get_parent(p);
         while(p == NodeTraits::get_right(x)){
            p = x;
            x = NodeTraits::get_parent(x);
         }
         return NodeTraits::get_right(p) != x ? x : uncast(p);
      }
   }
# 461 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static node_ptr prev_node(const node_ptr & node)
   {
      if(is_header(node)){
         return NodeTraits::get_right(node);

      }
      else if(NodeTraits::get_left(node)){
         return maximum(NodeTraits::get_left(node));
      }
      else {
         node_ptr p(node);
         node_ptr x = NodeTraits::get_parent(p);
         while(p == NodeTraits::get_left(x)){
            p = x;
            x = NodeTraits::get_parent(x);
         }
         return x;
      }
   }
# 488 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static node_ptr minimum (const node_ptr & node)
   {
      node_ptr p(node);
      for(node_ptr p_left = NodeTraits::get_left(p)
         ;p_left
         ;p_left = NodeTraits::get_left(p)){
         p = p_left;
      }
      return p;
   }
# 506 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static node_ptr maximum(const node_ptr & node)
   {
      node_ptr p(node);
      for(node_ptr p_right = NodeTraits::get_right(p)
         ;p_right
         ;p_right = NodeTraits::get_right(p)){
         p = p_right;
      }
      return p;
   }
# 526 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void init(const node_ptr & node)
   {
      NodeTraits::set_parent(node, node_ptr());
      NodeTraits::set_left(node, node_ptr());
      NodeTraits::set_right(node, node_ptr());
   };






   static bool inited(const const_node_ptr & node)
   {
      return !NodeTraits::get_parent(node) &&
             !NodeTraits::get_left(node) &&
             !NodeTraits::get_right(node) ;
   };
# 555 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void init_header(const node_ptr & header)
   {
      NodeTraits::set_parent(header, node_ptr());
      NodeTraits::set_left(header, header);
      NodeTraits::set_right(header, header);
   }
# 573 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template<class Disposer>
   static void clear_and_dispose(const node_ptr & header, Disposer disposer)
   {
      node_ptr source_root = NodeTraits::get_parent(header);
      if(!source_root)
         return;
      dispose_subtree(source_root, disposer);
      init_header(header);
   }
# 596 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
   {
      node_ptr leftmost = NodeTraits::get_left(header);
      if (leftmost == header)
         return node_ptr();
      node_ptr leftmost_parent(NodeTraits::get_parent(leftmost));
      node_ptr leftmost_right (NodeTraits::get_right(leftmost));
      bool is_root = leftmost_parent == header;

      if (leftmost_right){
         NodeTraits::set_parent(leftmost_right, leftmost_parent);
         NodeTraits::set_left(header, tree_algorithms::minimum(leftmost_right));

         if (is_root)
            NodeTraits::set_parent(header, leftmost_right);
         else
            NodeTraits::set_left(NodeTraits::get_parent(header), leftmost_right);
      }
      else if (is_root){
         NodeTraits::set_parent(header, node_ptr());
         NodeTraits::set_left(header, header);
         NodeTraits::set_right(header, header);
      }
      else{
         NodeTraits::set_left(leftmost_parent, node_ptr());
         NodeTraits::set_left(header, leftmost_parent);
      }
      return leftmost;
   }
# 633 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static std::size_t count(const const_node_ptr & subtree)
   {
      if(!subtree) return 0;
      std::size_t count = 0;
      node_ptr p = minimum(uncast(subtree));
      bool continue_looping = true;
      while(continue_looping){
         ++count;
         node_ptr p_right(NodeTraits::get_right(p));
         if(p_right){
            p = minimum(p_right);
         }
         else {
            for(;;){
               node_ptr q;
               if (p == subtree){
                  continue_looping = false;
                  break;
               }
               q = p;
               p = NodeTraits::get_parent(p);
               if (NodeTraits::get_left(p) == q)
                  break;
            }
         }
      }
      return count;
   }
# 669 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static std::size_t size(const const_node_ptr & header)
   {
      node_ptr beg(begin_node(header));
      node_ptr end(end_node(header));
      std::size_t i = 0;
      for(;beg != end; beg = next_node(beg)) ++i;
      return i;
   }
# 687 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void swap_tree(const node_ptr & header1, const node_ptr & header2)
   {
      if(header1 == header2)
         return;

      node_ptr tmp;


      tmp = NodeTraits::get_parent(header1);
      NodeTraits::set_parent(header1, NodeTraits::get_parent(header2));
      NodeTraits::set_parent(header2, tmp);

      tmp = NodeTraits::get_left(header1);
      NodeTraits::set_left(header1, NodeTraits::get_left(header2));
      NodeTraits::set_left(header2, tmp);

      tmp = NodeTraits::get_right(header1);
      NodeTraits::set_right(header1, NodeTraits::get_right(header2));
      NodeTraits::set_right(header2, tmp);


      node_ptr h1_parent(NodeTraits::get_parent(header1));
      if(h1_parent){
         NodeTraits::set_parent(h1_parent, header1);
      }
      else{
         NodeTraits::set_left(header1, header1);
         NodeTraits::set_right(header1, header1);
      }

      node_ptr h2_parent(NodeTraits::get_parent(header2));
      if(h2_parent){
         NodeTraits::set_parent(h2_parent, header2);
      }
      else{
         NodeTraits::set_left(header2, header2);
         NodeTraits::set_right(header2, header2);
      }
   }

   static bool is_header(const const_node_ptr & p)
   {
      node_ptr p_left (NodeTraits::get_left(p));
      node_ptr p_right(NodeTraits::get_right(p));
      if(!NodeTraits::get_parent(p) ||
         (p_left && p_right &&
            (p_left == p_right ||
               (NodeTraits::get_parent(p_left) != p ||
                NodeTraits::get_parent(p_right) != p ))


          )){
         return true;
      }
      return false;
   }
# 755 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr find
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      node_ptr end = uncast(header);
      node_ptr y = lower_bound(header, key, comp);
      return (y == end || comp(key, y)) ? end : y;
   }
# 783 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template< class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, node_ptr> bounded_range
      ( const const_node_ptr & header
      , const KeyType &lower_key
      , const KeyType &upper_key
      , KeyNodePtrCompare comp
      , bool left_closed
      , bool right_closed)
   {
      node_ptr y = uncast(header);
      node_ptr x = NodeTraits::get_parent(header);

      while(x){


         if(comp(x, lower_key)){

            ((comp(x, upper_key)) ? static_cast<void> (0) : __assert_fail ("comp(x, upper_key)", "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp", 800, __PRETTY_FUNCTION__));
            x = NodeTraits::get_right(x);
         }


         else if(comp(upper_key, x)){

            y = x;
            x = NodeTraits::get_left(x);
         }
         else{




            ((left_closed || right_closed || comp(lower_key, x) || comp(x, upper_key)) ? static_cast<void> (0) : __assert_fail ("left_closed || right_closed || comp(lower_key, x) || comp(x, upper_key)", "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp", 815, __PRETTY_FUNCTION__));
            return std::pair<node_ptr,node_ptr>(
               left_closed



                  ? lower_bound_loop(NodeTraits::get_left(x), x, lower_key, comp)


                  : upper_bound_loop(x, y, lower_key, comp)
            ,
               right_closed



                  ? upper_bound_loop(NodeTraits::get_right(x), y, upper_key, comp)


                  : lower_bound_loop(x, y, upper_key, comp)
            );
         }
      }
      return std::pair<node_ptr,node_ptr> (y, y);
   }
# 853 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, node_ptr> equal_range
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      return bounded_range(header, key, key, comp, true, true);
   }
# 872 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr lower_bound
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      return lower_bound_loop(NodeTraits::get_parent(header), uncast(header), key, comp);
   }
# 890 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr upper_bound
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   {
      return upper_bound_loop(NodeTraits::get_parent(header), uncast(header), key, comp);
   }
# 914 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static void insert_unique_commit
      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
   { return insert_commit(header, new_value, commit_data); }

   static void insert_commit
      (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data)
   {

      ((commit_data.node != node_ptr()) ? static_cast<void> (0) : __assert_fail ("commit_data.node != node_ptr()", "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp", 922, __PRETTY_FUNCTION__));
      node_ptr parent_node(commit_data.node);
      if(parent_node == header){
         NodeTraits::set_parent(header, new_node);
         NodeTraits::set_right(header, new_node);
         NodeTraits::set_left(header, new_node);
      }
      else if(commit_data.link_left){
         NodeTraits::set_left(parent_node, new_node);
         if(parent_node == NodeTraits::get_left(header))
             NodeTraits::set_left(header, new_node);
      }
      else{
         NodeTraits::set_right(parent_node, new_node);
         if(parent_node == NodeTraits::get_right(header))
             NodeTraits::set_right(header, new_node);
      }
      NodeTraits::set_parent(new_node, parent_node);
      NodeTraits::set_right(new_node, node_ptr());
      NodeTraits::set_left(new_node, node_ptr());
   }
# 978 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, bool> insert_unique_check
      (const const_node_ptr & header, const KeyType &key
      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
   {
      std::size_t depth = 0;
      node_ptr h(uncast(header));
      node_ptr y(h);
      node_ptr x(NodeTraits::get_parent(y));
      node_ptr prev = node_ptr();



      bool left_child = true;
      while(x){
         ++depth;
         y = x;
         x = (left_child = comp(key, x)) ?
               NodeTraits::get_left(x) : (prev = y, NodeTraits::get_right(x));
      }

      if(pdepth) *pdepth = depth;




      if(!prev || comp(prev, key)){
         commit_data.link_left = left_child;
         commit_data.node = y;
         return std::pair<node_ptr, bool>(node_ptr(), true);
      }


      else{
         return std::pair<node_ptr, bool>(prev, false);
      }
   }

   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, bool> insert_unique_check
      (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
   {

      if(hint == header || comp(key, hint)){
         node_ptr prev(hint);

         if(hint == begin_node(header)|| comp((prev = prev_node(hint)), key)){
            commit_data.link_left = unique(header) || !NodeTraits::get_left(hint);
            commit_data.node = commit_data.link_left ? hint : prev;
            if(pdepth){
               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
            }
            return std::pair<node_ptr, bool>(node_ptr(), true);
         }
      }

      return insert_unique_check(header, key, comp, commit_data, pdepth);
   }

   template<class NodePtrCompare>
   static void insert_equal_check
      (const node_ptr &header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
      , insert_commit_data &commit_data, std::size_t *pdepth = 0)
   {
      if(hint == header || !comp(hint, new_node)){
         node_ptr prev(hint);
         if(hint == NodeTraits::get_left(header) ||
            !comp(new_node, (prev = prev_node(hint)))){
            bool link_left = unique(header) || !NodeTraits::get_left(hint);
            commit_data.link_left = link_left;
            commit_data.node = link_left ? hint : prev;
            if(pdepth){
               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
            }
         }
         else{
            insert_equal_upper_bound_check(header, new_node, comp, commit_data, pdepth);
         }
      }
      else{
         insert_equal_lower_bound_check(header, new_node, comp, commit_data, pdepth);
      }
   }

   template<class NodePtrCompare>
   static void insert_equal_upper_bound_check
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
   { insert_equal_check_impl(true, h, new_node, comp, commit_data, pdepth); }

   template<class NodePtrCompare>
   static void insert_equal_lower_bound_check
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
   { insert_equal_check_impl(false, h, new_node, comp, commit_data, pdepth); }

   template<class NodePtrCompare>
   static node_ptr insert_equal
      (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
   {
      insert_commit_data commit_data;
      insert_equal_check(h, hint, new_node, comp, commit_data, pdepth);
      insert_commit(h, new_node, commit_data);
      return new_node;
   }

   template<class NodePtrCompare>
   static node_ptr insert_equal_upper_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
   {
      insert_commit_data commit_data;
      insert_equal_upper_bound_check(h, new_node, comp, commit_data, pdepth);
      insert_commit(h, new_node, commit_data);
      return new_node;
   }

   template<class NodePtrCompare>
   static node_ptr insert_equal_lower_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
   {
      insert_commit_data commit_data;
      insert_equal_lower_bound_check(h, new_node, comp, commit_data, pdepth);
      insert_commit(h, new_node, commit_data);
      return new_node;
   }

   static node_ptr insert_before
      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node, std::size_t *pdepth = 0)
   {
      insert_commit_data commit_data;
      insert_before_check(header, pos, commit_data, pdepth);
      insert_commit(header, new_node, commit_data);
      return new_node;
   }

   static void insert_before_check
      (const node_ptr &header, const node_ptr & pos
      , insert_commit_data &commit_data, std::size_t *pdepth = 0)
   {
      node_ptr prev(pos);
      if(pos != NodeTraits::get_left(header))
         prev = prev_node(pos);
      bool link_left = unique(header) || !NodeTraits::get_left(pos);
      commit_data.link_left = link_left;
      commit_data.node = link_left ? pos : prev;
      if(pdepth){
         *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
      }
   }

   static void push_back
      (const node_ptr & header, const node_ptr & new_node, std::size_t *pdepth = 0)
   {
      insert_commit_data commit_data;
      push_back_check(header, commit_data, pdepth);
      insert_commit(header, new_node, commit_data);
   }

   static void push_back_check
      (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
   {
      node_ptr prev(NodeTraits::get_right(header));
      if(pdepth){
         *pdepth = prev == header ? 0 : depth(prev) + 1;
      }
      commit_data.link_left = false;
      commit_data.node = prev;
   }

   static void push_front
      (const node_ptr & header, const node_ptr & new_node, std::size_t *pdepth = 0)
   {
      insert_commit_data commit_data;
      push_front_check(header, commit_data, pdepth);
      insert_commit(header, new_node, commit_data);
   }

   static void push_front_check
      (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
   {
      node_ptr pos(NodeTraits::get_left(header));
      if(pdepth){
         *pdepth = pos == header ? 0 : depth(pos) + 1;
      }
      commit_data.link_left = true;
      commit_data.node = pos;
   }
# 1174 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static std::size_t depth(const const_node_ptr & node)
   {
      const_node_ptr p(node);
      std::size_t depth = 0;
      node_ptr p_parent;
      while(p != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(p))){
         ++depth;
         p = p_parent;
      }
      return depth;
   }
# 1203 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   template <class Cloner, class Disposer>
   static void clone
      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
   {
      if(!unique(target_header)){
         clear_and_dispose(target_header, disposer);
      }

      node_ptr leftmost, rightmost;
      node_ptr new_root = clone_subtree
         (source_header, target_header, cloner, disposer, leftmost, rightmost);


      NodeTraits::set_parent(target_header, new_root);
      NodeTraits::set_left (target_header, leftmost);
      NodeTraits::set_right (target_header, rightmost);
   }

   template <class Cloner, class Disposer>
   static node_ptr clone_subtree
      (const const_node_ptr &source_parent, const node_ptr &target_parent
      , Cloner cloner, Disposer disposer
      , node_ptr &leftmost_out, node_ptr &rightmost_out
      )
   {
      node_ptr target_sub_root = target_parent;
      node_ptr source_root = NodeTraits::get_parent(source_parent);
      if(!source_root){
         leftmost_out = rightmost_out = source_root;
      }
      else{

         node_ptr current = source_root;
         node_ptr insertion_point = target_sub_root = cloner(current);


         node_ptr leftmost = target_sub_root;
         node_ptr rightmost = target_sub_root;


         NodeTraits::set_left(target_sub_root, node_ptr());
         NodeTraits::set_right(target_sub_root, node_ptr());
         NodeTraits::set_parent(target_sub_root, target_parent);

         dispose_subtree_disposer<Disposer> rollback(disposer, target_sub_root);
         while(true) {

            if( NodeTraits::get_left(current) &&
               !NodeTraits::get_left(insertion_point)) {
               current = NodeTraits::get_left(current);
               node_ptr temp = insertion_point;

               insertion_point = cloner(current);
               NodeTraits::set_left (insertion_point, node_ptr());
               NodeTraits::set_right (insertion_point, node_ptr());

               NodeTraits::set_parent(insertion_point, temp);
               NodeTraits::set_left (temp, insertion_point);

               if(rightmost == target_sub_root)
                  leftmost = insertion_point;
            }

            else if( NodeTraits::get_right(current) &&
                     !NodeTraits::get_right(insertion_point)){
               current = NodeTraits::get_right(current);
               node_ptr temp = insertion_point;

               insertion_point = cloner(current);
               NodeTraits::set_left (insertion_point, node_ptr());
               NodeTraits::set_right (insertion_point, node_ptr());

               NodeTraits::set_parent(insertion_point, temp);
               NodeTraits::set_right (temp, insertion_point);

               rightmost = insertion_point;
            }

            else if(current == source_root){
               break;
            }
            else{

               current = NodeTraits::get_parent(current);
               insertion_point = NodeTraits::get_parent(insertion_point);
            }
         }
         rollback.release();
         leftmost_out = leftmost;
         rightmost_out = rightmost;
      }
      return target_sub_root;
   }

   template<class Disposer>
   static void dispose_subtree(const node_ptr & node, Disposer disposer)
   {
      node_ptr save;
      node_ptr x(node);
      while (x){
         save = NodeTraits::get_left(x);
         if (save) {

            NodeTraits::set_left(x, NodeTraits::get_right(save));
            NodeTraits::set_right(save, x);
         }
         else {
            save = NodeTraits::get_right(x);
            init(x);
            disposer(x);
         }
         x = save;
      }
   }
# 1325 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static bool is_left_child(const node_ptr & p)
   { return NodeTraits::get_left(NodeTraits::get_parent(p)) == p; }
# 1335 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static bool is_right_child(const node_ptr & p)
   { return NodeTraits::get_right(NodeTraits::get_parent(p)) == p; }


   static void replace_own_impl(const node_ptr & own, const node_ptr & x, const node_ptr & header, const node_ptr & own_parent, bool own_was_left)
   {
      if(NodeTraits::get_parent(header) == own)
         NodeTraits::set_parent(header, x);
      else if(own_was_left)
         NodeTraits::set_left(own_parent, x);
      else
         NodeTraits::set_right(own_parent, x);
   }



   static void replace_own(const node_ptr & own, const node_ptr & x, const node_ptr & header)
   {
      node_ptr own_parent(NodeTraits::get_parent(own));
      bool own_is_left(NodeTraits::get_left(own_parent) == own);
      replace_own_impl(own, x, header, own_parent, own_is_left);
   }


   static node_ptr rotate_left(const node_ptr & p)
   {
      node_ptr x(NodeTraits::get_right(p));
      node_ptr x_left(NodeTraits::get_left(x));
      NodeTraits::set_right(p, x_left);
      if(x_left){
         NodeTraits::set_parent(x_left, p);
      }
      NodeTraits::set_left(x, p);
      NodeTraits::set_parent(p, x);
      return x;
   }


   static void rotate_left(const node_ptr & p, const node_ptr & header)
   {
      bool p_was_left(is_left_child(p));
      node_ptr p_old_parent(NodeTraits::get_parent(p));
      node_ptr x(rotate_left(p));
      NodeTraits::set_parent(x, p_old_parent);
      replace_own_impl(p, x, header, p_old_parent, p_was_left);
   }


   static node_ptr rotate_right(const node_ptr & p)
   {
      node_ptr x(NodeTraits::get_left(p));
      node_ptr x_right(NodeTraits::get_right(x));
      NodeTraits::set_left(p, x_right);
      if(x_right){
         NodeTraits::set_parent(x_right, p);
      }
      NodeTraits::set_right(x, p);
      NodeTraits::set_parent(p, x);
      return x;
   }


   static void rotate_right(const node_ptr & p, const node_ptr & header)
   {
      bool p_was_left(is_left_child(p));
      node_ptr p_old_parent(NodeTraits::get_parent(p));
      node_ptr x(rotate_right(p));
      NodeTraits::set_parent(x, p_old_parent);
      replace_own_impl(p, x, header, p_old_parent, p_was_left);
   }

   static void erase(const node_ptr & header, const node_ptr & z)
   {
      data_for_rebalance ignored;
      erase_impl(header, z, ignored);
   }

   struct data_for_rebalance
   {
      node_ptr x;
      node_ptr x_parent;
      node_ptr y;
   };

   template<class F>
   static void erase(const node_ptr & header, const node_ptr & z, F z_and_successor_fixup, data_for_rebalance &info)
   {
      erase_impl(header, z, info);
      if(info.y != z){
         z_and_successor_fixup(z, info.y);
      }
   }

   static void unlink(const node_ptr & node)
   {
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!is_header(x))
            x = NodeTraits::get_parent(x);
         erase(x, node);
      }
   }

   static void tree_to_vine(const node_ptr & header)
   { subtree_to_vine(NodeTraits::get_parent(header)); }

   static void vine_to_tree(const node_ptr & header, std::size_t count)
   { vine_to_subtree(NodeTraits::get_parent(header), count); }

   static void rebalance(const node_ptr & header)
   {



      std::size_t len = 0;
      subtree_to_vine(NodeTraits::get_parent(header), &len);
      vine_to_subtree(NodeTraits::get_parent(header), len);
   }

   static node_ptr rebalance_subtree(const node_ptr & old_root)
   {
      std::size_t len = 0;
      node_ptr new_root = subtree_to_vine(old_root, &len);
      return vine_to_subtree(new_root, len);
   }

   static node_ptr subtree_to_vine(const node_ptr & old_root, std::size_t *plen = 0)
   {
      std::size_t len;
      len = 0;
      if(!old_root) return node_ptr();






      node_ptr super_root = NodeTraits::get_parent(old_root);
      ((super_root) ? static_cast<void> (0) : __assert_fail ("super_root", "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp", 1473, __PRETTY_FUNCTION__));


      node_ptr super_root_right_backup = NodeTraits::get_right(super_root);
      bool super_root_is_header = is_header(super_root);
      bool old_root_is_right = is_right_child(old_root);

      node_ptr x(old_root);
      node_ptr new_root(x);
      node_ptr save;
      bool moved_to_right = false;
      for( ; x; x = save){
         save = NodeTraits::get_left(x);
         if(save){

            node_ptr save_right = NodeTraits::get_right(save);
            node_ptr x_parent = NodeTraits::get_parent(x);
            NodeTraits::set_parent(save, x_parent);
            NodeTraits::set_right (x_parent, save);
            NodeTraits::set_parent(x, save);
            NodeTraits::set_right (save, x);
            NodeTraits::set_left(x, save_right);
            if(save_right)
               NodeTraits::set_parent(save_right, x);
            if(!moved_to_right)
               new_root = save;
         }
         else{
            moved_to_right = true;
            save = NodeTraits::get_right(x);
            ++len;
         }
      }

      if(super_root_is_header){
         NodeTraits::set_right(super_root, super_root_right_backup);
         NodeTraits::set_parent(super_root, new_root);
      }
      else if(old_root_is_right){
         NodeTraits::set_right(super_root, new_root);
      }
      else{
         NodeTraits::set_right(super_root, super_root_right_backup);
         NodeTraits::set_left(super_root, new_root);
      }
      if(plen) *plen = len;
      return new_root;
   }

   static node_ptr vine_to_subtree(const node_ptr & old_root, std::size_t count)
   {
      std::size_t leaf_nodes = count + 1 - ((std::size_t) 1 << floor_log2 (count + 1));
      std::size_t vine_nodes = count - leaf_nodes;

      node_ptr new_root = compress_subtree(old_root, leaf_nodes);
      while(vine_nodes > 1){
         vine_nodes /= 2;
         new_root = compress_subtree(new_root, vine_nodes);
      }
      return new_root;
   }

   static node_ptr compress_subtree(const node_ptr & old_root, std::size_t count)
   {
      if(!old_root) return old_root;






      node_ptr super_root = NodeTraits::get_parent(old_root);
      ((super_root) ? static_cast<void> (0) : __assert_fail ("super_root", "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp", 1545, __PRETTY_FUNCTION__));


      node_ptr super_root_right_backup = NodeTraits::get_right(super_root);
      bool super_root_is_header = is_header(super_root);
      bool old_root_is_right = is_right_child(old_root);


      NodeTraits::set_right(super_root, old_root);


      node_ptr even_parent = super_root;
      node_ptr new_root = old_root;

      while(count--){
         node_ptr even = NodeTraits::get_right(even_parent);
         node_ptr odd = NodeTraits::get_right(even);

         if(new_root == old_root)
            new_root = odd;

         node_ptr even_right = NodeTraits::get_left(odd);
         NodeTraits::set_right(even, even_right);
         if (even_right)
            NodeTraits::set_parent(even_right, even);

         NodeTraits::set_right(even_parent, odd);
         NodeTraits::set_parent(odd, even_parent);
         NodeTraits::set_left(odd, even);
         NodeTraits::set_parent(even, odd);
         even_parent = odd;
      }

      if(super_root_is_header){
         NodeTraits::set_parent(super_root, new_root);
         NodeTraits::set_right(super_root, super_root_right_backup);
      }
      else if(old_root_is_right){
         NodeTraits::set_right(super_root, new_root);
      }
      else{
         NodeTraits::set_left(super_root, new_root);
         NodeTraits::set_right(super_root, super_root_right_backup);
      }
      return new_root;
   }
# 1599 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp"
   static node_ptr get_root(const node_ptr & node)
   {
      (((!inited(node))) ? static_cast<void> (0) : __assert_fail ("(!inited(node))", "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp", 1601, __PRETTY_FUNCTION__));
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!is_header(x)){
            x = NodeTraits::get_parent(x);
         }
         return x;
      }
      else{
         return node;
      }
   }

   private:

   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr lower_bound_loop
      (node_ptr x, node_ptr y, const KeyType &key, KeyNodePtrCompare comp)
   {
      while(x){
         if(comp(x, key)){
            x = NodeTraits::get_right(x);
         }
         else{
            y = x;
            x = NodeTraits::get_left(x);
         }
      }
      return y;
   }

   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr upper_bound_loop
      (node_ptr x, node_ptr y, const KeyType &key, KeyNodePtrCompare comp)
   {
      while(x){
         if(comp(key, x)){
            y = x;
            x = NodeTraits::get_left(x);
         }
         else{
            x = NodeTraits::get_right(x);
         }
      }
      return y;
   }


   template<class NodePtrCompare>
   static void insert_equal_check_impl
      (bool upper, const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
   {
      std::size_t depth = 0;
      node_ptr y(h);
      node_ptr x(NodeTraits::get_parent(y));
      bool link_left;

      if(upper){
         while(x){
            ++depth;
            y = x;
            x = comp(new_node, x) ?
                  NodeTraits::get_left(x) : NodeTraits::get_right(x);
         }
         link_left = (y == h) || comp(new_node, y);
      }
      else{
         while(x){
            ++depth;
            y = x;
            x = !comp(x, new_node) ?
                  NodeTraits::get_left(x) : NodeTraits::get_right(x);
         }
         link_left = (y == h) || !comp(y, new_node);
      }

      commit_data.link_left = link_left;
      commit_data.node = y;
      if(pdepth) *pdepth = depth;
   }

   static void erase_impl(const node_ptr & header, const node_ptr & z, data_for_rebalance &info)
   {
      node_ptr y(z);
      node_ptr x;
      node_ptr x_parent = node_ptr();
      node_ptr z_left(NodeTraits::get_left(z));
      node_ptr z_right(NodeTraits::get_right(z));
      if(!z_left){
         x = z_right;
      }
      else if(!z_right){
         x = z_left;
      }
      else{

         y = tree_algorithms::minimum (z_right);
         x = NodeTraits::get_right(y);
      }

      if(y != z){

         NodeTraits::set_parent(NodeTraits::get_left(z), y);
         NodeTraits::set_left(y, NodeTraits::get_left(z));
         if(y != NodeTraits::get_right(z)){
            x_parent = NodeTraits::get_parent(y);
            if(x)
               NodeTraits::set_parent(x, x_parent);
            NodeTraits::set_left(x_parent, x);
            NodeTraits::set_right(y, NodeTraits::get_right(z));
            NodeTraits::set_parent(NodeTraits::get_right(z), y);
         }
         else
            x_parent = y;
         tree_algorithms::replace_own (z, y, header);
         NodeTraits::set_parent(y, NodeTraits::get_parent(z));
      }
      else {
         x_parent = NodeTraits::get_parent(z);
         if(x)
            NodeTraits::set_parent(x, x_parent);
         tree_algorithms::replace_own (z, x, header);
         if(NodeTraits::get_left(header) == z){
            NodeTraits::set_left(header, !NodeTraits::get_right(z) ?
               NodeTraits::get_parent(z) :
               tree_algorithms::minimum (x));
         }
         if(NodeTraits::get_right(header) == z){
            NodeTraits::set_right(header, !NodeTraits::get_left(z) ?
                              NodeTraits::get_parent(z) :
                              tree_algorithms::maximum(x));
         }
      }

      info.x = x;
      info.x_parent = x_parent;
      info.y = y;
   }
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 1746 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_algorithms.hpp" 2
# 59 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2


namespace boost {
namespace intrusive {
# 114 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
template<class NodeTraits>
class rbtree_algorithms
{
   public:
   typedef NodeTraits node_traits;
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef typename NodeTraits::color color;


   private:

   typedef detail::tree_algorithms<NodeTraits> tree_algorithms;

   template<class F>
   struct rbtree_node_cloner
      : private detail::ebo_functor_holder<F>
   {
      typedef detail::ebo_functor_holder<F> base_t;

      rbtree_node_cloner(F f)
         : base_t(f)
      {}

      node_ptr operator()(const node_ptr & p)
      {
         node_ptr n = base_t::get()(p);
         NodeTraits::set_color(n, NodeTraits::get_color(p));
         return n;
      }
   };

   struct rbtree_erase_fixup
   {
      void operator()(const node_ptr & to_erase, const node_ptr & successor)
      {

         color tmp(NodeTraits::get_color(successor));
         NodeTraits::set_color(successor, NodeTraits::get_color(to_erase));
         NodeTraits::set_color(to_erase, tmp);
      }
   };

   static node_ptr uncast(const const_node_ptr & ptr)
   { return pointer_traits<node_ptr>::const_cast_from(ptr); }


   public:
   static node_ptr begin_node(const const_node_ptr & header)
   { return tree_algorithms::begin_node(header); }

   static node_ptr end_node(const const_node_ptr & header)
   { return tree_algorithms::end_node(header); }



   typedef typename tree_algorithms::insert_commit_data insert_commit_data;
# 182 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void swap_tree(const node_ptr & header1, const node_ptr & header2)
   { return tree_algorithms::swap_tree(header1, header2); }
# 200 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
   {
      if(node1 == node2)
         return;

      node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
      swap_nodes(node1, header1, node2, header2);
   }
# 224 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
   {
      if(node1 == node2) return;

      tree_algorithms::swap_nodes(node1, header1, node2, header2);

      color c = NodeTraits::get_color(node1);
      NodeTraits::set_color(node1, NodeTraits::get_color(node2));
      NodeTraits::set_color(node2, c);
   }
# 251 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
   {
      if(node_to_be_replaced == new_node)
         return;
      replace_node(node_to_be_replaced, tree_algorithms::get_header(node_to_be_replaced), new_node);
   }
# 274 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
   {
      tree_algorithms::replace_node(node_to_be_replaced, header, new_node);
      NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced));
   }
# 287 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void unlink(const node_ptr & node)
   {
      node_ptr x = NodeTraits::get_parent(node);
      if(x){
         while(!is_header(x))
            x = NodeTraits::get_parent(x);
         erase(x, node);
      }
   }
# 310 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
   { return tree_algorithms::unlink_leftmost_without_rebalance(header); }
# 321 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static bool unique(const const_node_ptr & node)
   { return tree_algorithms::unique(node); }
# 331 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static std::size_t count(const const_node_ptr & node)
   { return tree_algorithms::count(node); }
# 341 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static std::size_t size(const const_node_ptr & header)
   { return tree_algorithms::size(header); }
# 351 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static node_ptr next_node(const node_ptr & p)
   { return tree_algorithms::next_node(p); }
# 361 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static node_ptr prev_node(const node_ptr & p)
   { return tree_algorithms::prev_node(p); }
# 373 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void init(const node_ptr & node)
   { tree_algorithms::init(node); }
# 386 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void init_header(const node_ptr & header)
   {
      tree_algorithms::init_header(header);
      NodeTraits::set_color(header, NodeTraits::red());
   }
# 400 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static node_ptr erase(const node_ptr & header, const node_ptr & z)
   {
      typename tree_algorithms::data_for_rebalance info;
      tree_algorithms::erase(header, z, rbtree_erase_fixup(), info);
      node_ptr x = info.x;
      node_ptr x_parent = info.x_parent;


      if(NodeTraits::get_color(z) != NodeTraits::red()){
         rebalance_after_erasure(header, x, x_parent);
      }
      return z;
   }
# 431 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template <class Cloner, class Disposer>
   static void clone
      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
   {
      rbtree_node_cloner<Cloner> new_cloner(cloner);
      tree_algorithms::clone(source_header, target_header, new_cloner, disposer);
   }
# 450 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class Disposer>
   static void clear_and_dispose(const node_ptr & header, Disposer disposer)
   { tree_algorithms::clear_and_dispose(header, disposer); }
# 466 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr lower_bound
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   { return tree_algorithms::lower_bound(header, key, comp); }
# 482 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr upper_bound
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   { return tree_algorithms::upper_bound(header, key, comp); }
# 498 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static node_ptr find
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   { return tree_algorithms::find(header, key, comp); }
# 516 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, node_ptr> equal_range
      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
   { return tree_algorithms::equal_range(header, key, comp); }
# 540 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, node_ptr> bounded_range
      (const const_node_ptr & header, const KeyType &lower_key, const KeyType &upper_key, KeyNodePtrCompare comp
      , bool left_closed, bool right_closed)
   { return tree_algorithms::bounded_range(header, lower_key, upper_key, comp, left_closed, right_closed); }
# 558 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class NodePtrCompare>
   static node_ptr insert_equal_upper_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
   {
      tree_algorithms::insert_equal_upper_bound(h, new_node, comp);
      rebalance_after_insertion(h, new_node);
      return new_node;
   }
# 579 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class NodePtrCompare>
   static node_ptr insert_equal_lower_bound
      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
   {
      tree_algorithms::insert_equal_lower_bound(h, new_node, comp);
      rebalance_after_insertion(h, new_node);
      return new_node;
   }
# 602 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class NodePtrCompare>
   static node_ptr insert_equal
      (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
   {
      tree_algorithms::insert_equal(header, hint, new_node, comp);
      rebalance_after_insertion(header, new_node);
      return new_node;
   }
# 625 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static node_ptr insert_before
      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
   {
      tree_algorithms::insert_before(header, pos, new_node);
      rebalance_after_insertion(header, new_node);
      return new_node;
   }
# 646 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void push_back(const node_ptr & header, const node_ptr & new_node)
   {
      tree_algorithms::push_back(header, new_node);
      rebalance_after_insertion(header, new_node);
   }
# 665 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void push_front(const node_ptr & header, const node_ptr & new_node)
   {
      tree_algorithms::push_front(header, new_node);
      rebalance_after_insertion(header, new_node);
   }
# 705 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, bool> insert_unique_check
      (const const_node_ptr & header, const KeyType &key
      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
   { return tree_algorithms::insert_unique_check(header, key, comp, commit_data); }
# 750 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   template<class KeyType, class KeyNodePtrCompare>
   static std::pair<node_ptr, bool> insert_unique_check
      (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
   { return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data); }
# 773 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static void insert_unique_commit
      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
   {
      tree_algorithms::insert_unique_commit(header, new_value, commit_data);
      rebalance_after_insertion(header, new_value);
   }
# 787 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static node_ptr get_header(const node_ptr & n)
   { return tree_algorithms::get_header(n); }


   private:
# 800 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp"
   static bool is_header(const const_node_ptr & p)
   {
      return NodeTraits::get_color(p) == NodeTraits::red() &&
            tree_algorithms::is_header(p);


   }

   static void rebalance_after_erasure(const node_ptr & header, const node_ptr &xnode, const node_ptr &xnode_parent)
   {
      node_ptr x(xnode), x_parent(xnode_parent);
      while(x != NodeTraits::get_parent(header) && (x == node_ptr() || NodeTraits::get_color(x) == NodeTraits::black())){
         if(x == NodeTraits::get_left(x_parent)){
            node_ptr w = NodeTraits::get_right(x_parent);
            if(NodeTraits::get_color(w) == NodeTraits::red()){
               NodeTraits::set_color(w, NodeTraits::black());
               NodeTraits::set_color(x_parent, NodeTraits::red());
               tree_algorithms::rotate_left(x_parent, header);
               w = NodeTraits::get_right(x_parent);
            }
            if((NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()) &&
               (NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black())){
               NodeTraits::set_color(w, NodeTraits::red());
               x = x_parent;
               x_parent = NodeTraits::get_parent(x_parent);
            }
            else {
               if(NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()){
                  NodeTraits::set_color(NodeTraits::get_left(w), NodeTraits::black());
                  NodeTraits::set_color(w, NodeTraits::red());
                  tree_algorithms::rotate_right(w, header);
                  w = NodeTraits::get_right(x_parent);
               }
               NodeTraits::set_color(w, NodeTraits::get_color(x_parent));
               NodeTraits::set_color(x_parent, NodeTraits::black());
               if(NodeTraits::get_right(w))
                  NodeTraits::set_color(NodeTraits::get_right(w), NodeTraits::black());
               tree_algorithms::rotate_left(x_parent, header);
               break;
            }
         }
         else {

            node_ptr w = NodeTraits::get_left(x_parent);
            if(NodeTraits::get_color(w) == NodeTraits::red()){
               NodeTraits::set_color(w, NodeTraits::black());
               NodeTraits::set_color(x_parent, NodeTraits::red());
               tree_algorithms::rotate_right(x_parent, header);
               w = NodeTraits::get_left(x_parent);
            }
            if((NodeTraits::get_right(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_right(w)) == NodeTraits::black()) &&
               (NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black())){
               NodeTraits::set_color(w, NodeTraits::red());
               x = x_parent;
               x_parent = NodeTraits::get_parent(x_parent);
            }
            else {
               if(NodeTraits::get_left(w) == node_ptr() || NodeTraits::get_color(NodeTraits::get_left(w)) == NodeTraits::black()){
                  NodeTraits::set_color(NodeTraits::get_right(w), NodeTraits::black());
                  NodeTraits::set_color(w, NodeTraits::red());
                  tree_algorithms::rotate_left(w, header);
                  w = NodeTraits::get_left(x_parent);
               }
               NodeTraits::set_color(w, NodeTraits::get_color(x_parent));
               NodeTraits::set_color(x_parent, NodeTraits::black());
               if(NodeTraits::get_left(w))
                  NodeTraits::set_color(NodeTraits::get_left(w), NodeTraits::black());
               tree_algorithms::rotate_right(x_parent, header);
               break;
            }
         }
      }
      if(x)
         NodeTraits::set_color(x, NodeTraits::black());
   }


   static void rebalance_after_insertion(const node_ptr & header, const node_ptr &pnode)
   {
      node_ptr p(pnode);
      NodeTraits::set_color(p, NodeTraits::red());
      while(p != NodeTraits::get_parent(header) && NodeTraits::get_color(NodeTraits::get_parent(p)) == NodeTraits::red()){
         node_ptr p_parent(NodeTraits::get_parent(p));
         node_ptr p_parent_parent(NodeTraits::get_parent(p_parent));
         if(tree_algorithms::is_left_child(p_parent)){
            node_ptr x = NodeTraits::get_right(p_parent_parent);
            if(x && NodeTraits::get_color(x) == NodeTraits::red()){
               NodeTraits::set_color(p_parent, NodeTraits::black());
               NodeTraits::set_color(p_parent_parent, NodeTraits::red());
               NodeTraits::set_color(x, NodeTraits::black());
               p = p_parent_parent;
            }
            else {
               if(!tree_algorithms::is_left_child(p)){
                  p = p_parent;
                  tree_algorithms::rotate_left(p, header);
               }
               node_ptr new_p_parent(NodeTraits::get_parent(p));
               node_ptr new_p_parent_parent(NodeTraits::get_parent(new_p_parent));
               NodeTraits::set_color(new_p_parent, NodeTraits::black());
               NodeTraits::set_color(new_p_parent_parent, NodeTraits::red());
               tree_algorithms::rotate_right(new_p_parent_parent, header);
            }
         }
         else{
            node_ptr x = NodeTraits::get_left(p_parent_parent);
            if(x && NodeTraits::get_color(x) == NodeTraits::red()){
               NodeTraits::set_color(p_parent, NodeTraits::black());
               NodeTraits::set_color(p_parent_parent, NodeTraits::red());
               NodeTraits::set_color(x, NodeTraits::black());
               p = p_parent_parent;
            }
            else{
               if(tree_algorithms::is_left_child(p)){
                  p = p_parent;
                  tree_algorithms::rotate_right(p, header);
               }
               node_ptr new_p_parent(NodeTraits::get_parent(p));
               node_ptr new_p_parent_parent(NodeTraits::get_parent(new_p_parent));
               NodeTraits::set_color(new_p_parent, NodeTraits::black());
               NodeTraits::set_color(new_p_parent_parent, NodeTraits::red());
               tree_algorithms::rotate_left(new_p_parent_parent, header);
            }
         }
      }
      NodeTraits::set_color(NodeTraits::get_parent(header), NodeTraits::black());
   }

};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 934 "/opt/sevenflow/boost/include/boost/intrusive/rbtree_algorithms.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/pointer_plus_bits.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/intrusive/pointer_plus_bits.hpp"
namespace boost {
namespace intrusive {





template<class VoidPointer, std::size_t Alignment>
struct max_pointer_plus_bits
{
   static const std::size_t value = 0;
};




template<std::size_t Alignment>
struct max_pointer_plus_bits<void*, Alignment>
{
   static const std::size_t value = detail::ls_zeros<Alignment>::value;
};
# 49 "/opt/sevenflow/boost/include/boost/intrusive/pointer_plus_bits.hpp"
template<class Pointer, std::size_t NumBits>
struct pointer_plus_bits;



template<class T, std::size_t NumBits>
struct pointer_plus_bits<T*, NumBits>
{
   static const std::size_t Mask = ((std::size_t(1u) << NumBits) - 1);
   typedef T* pointer;

   static pointer get_pointer(pointer n)
   { return pointer(std::size_t(n) & ~Mask); }

   static void set_pointer(pointer &n, pointer p)
   {
      ((0 == (std::size_t(p) & Mask)) ? static_cast<void> (0) : __assert_fail ("0 == (std::size_t(p) & Mask)", "/opt/sevenflow/boost/include/boost/intrusive/pointer_plus_bits.hpp", 65, __PRETTY_FUNCTION__));
      n = pointer(std::size_t(p) | (std::size_t(n) & Mask));
   }

   static std::size_t get_bits(pointer n)
   { return (std::size_t(n) & Mask); }

   static void set_bits(pointer &n, std::size_t c)
   {
      ((c <= Mask) ? static_cast<void> (0) : __assert_fail ("c <= Mask", "/opt/sevenflow/boost/include/boost/intrusive/pointer_plus_bits.hpp", 74, __PRETTY_FUNCTION__));
      n = pointer(std::size_t(get_pointer(n)) | c);
   }
};

}
}
# 22 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2


namespace boost {
namespace intrusive {
# 34 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp"
template<class VoidPointer>
struct compact_rbtree_node
{
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer
         <compact_rbtree_node<VoidPointer> >::type node_ptr;
   enum color { red_t, black_t };
   node_ptr parent_, left_, right_;
};


template<class VoidPointer>
struct rbtree_node
{
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer
         <rbtree_node<VoidPointer> >::type node_ptr;

   enum color { red_t, black_t };
   node_ptr parent_, left_, right_;
   color color_;
};



template<class VoidPointer>
struct default_rbtree_node_traits_impl
{
   typedef rbtree_node<VoidPointer> node;

   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<node>::type node_ptr;
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

   typedef typename node::color color;

   static const node_ptr & get_parent(const const_node_ptr & n)
   { return n->parent_; }

   static void set_parent(const node_ptr & n, const node_ptr & p)
   { n->parent_ = p; }

   static const node_ptr & get_left(const const_node_ptr & n)
   { return n->left_; }

   static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   static const node_ptr & get_right(const const_node_ptr & n)
   { return n->right_; }

   static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }

   static color get_color(const const_node_ptr & n)
   { return n->color_; }

   static void set_color(const node_ptr & n, color c)
   { n->color_ = c; }

   static color black()
   { return node::black_t; }

   static color red()
   { return node::red_t; }
};



template<class VoidPointer>
struct compact_rbtree_node_traits_impl
{
   typedef compact_rbtree_node<VoidPointer> node;
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<node>::type node_ptr;
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

   typedef pointer_plus_bits<node_ptr, 1> ptr_bit;

   typedef typename node::color color;

   static node_ptr get_parent(const const_node_ptr & n)
   { return ptr_bit::get_pointer(n->parent_); }

   static void set_parent(const node_ptr & n, const node_ptr & p)
   { ptr_bit::set_pointer(n->parent_, p); }

   static const node_ptr & get_left(const const_node_ptr & n)
   { return n->left_; }

   static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   static const node_ptr & get_right(const const_node_ptr & n)
   { return n->right_; }

   static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }

   static color get_color(const const_node_ptr & n)
   { return (color)ptr_bit::get_bits(n->parent_); }

   static void set_color(const node_ptr & n, color c)
   { ptr_bit::set_bits(n->parent_, c != 0); }

   static color black()
   { return node::black_t; }

   static color red()
   { return node::red_t; }
};


template<class VoidPointer, bool Compact>
struct rbtree_node_traits_dispatch
   : public default_rbtree_node_traits_impl<VoidPointer>
{};

template<class VoidPointer>
struct rbtree_node_traits_dispatch<VoidPointer, true>
   : public compact_rbtree_node_traits_impl<VoidPointer>
{};


template<class VoidPointer, bool OptimizeSize = false>
struct rbtree_node_traits
   : public rbtree_node_traits_dispatch
         < VoidPointer
         , OptimizeSize &&
           (max_pointer_plus_bits
            < VoidPointer
            , detail::alignment_of<compact_rbtree_node<VoidPointer> >::value
            >::value >= 1)
         >
{};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 176 "/opt/sevenflow/boost/include/boost/intrusive/detail/rbtree_node.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp" 2







namespace boost {
namespace intrusive {



struct default_tag;
struct member_tag;

namespace detail{

struct default_hook_tag{};
# 44 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp"
struct default_list_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_list_hook type; };};
struct default_slist_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_slist_hook type; };};
struct default_set_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_set_hook type; };};
struct default_uset_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_uset_hook type; };};
struct default_avl_set_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_avl_set_hook type; };};
struct default_splay_set_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_splay_set_hook type; };};
struct default_bs_set_hook : public default_hook_tag{ template <class T> struct apply { typedef typename T::default_bs_set_hook type; };};



template <class ValueTraits>
struct eval_value_traits
{
   typedef typename ValueTraits::value_traits type;
};

template <class T>
struct external_bucket_traits_is_true
{
   static const bool value = external_bucket_traits_bool<T>::value == 3;
};

template <class BucketTraits>
struct eval_bucket_traits
{
   typedef typename BucketTraits::bucket_traits type;
};

template <class T, class BaseHook>
struct concrete_hook_base_value_traits
{
   typedef typename BaseHook::boost_intrusive_tags tags;
   typedef detail::base_hook_traits
      < T
      , typename tags::node_traits
      , tags::link_mode
      , typename tags::tag
      , tags::hook_type> type;
};

template <class BaseHook>
struct concrete_hook_base_node_traits
{ typedef typename BaseHook::boost_intrusive_tags::node_traits type; };

template <class T, class BaseHook>
struct any_hook_base_value_traits
{
   typedef typename BaseHook::boost_intrusive_tags tags;
   typedef detail::base_hook_traits
      < T
      , typename BaseHook::node_traits
      , tags::link_mode
      , typename tags::tag
      , tags::hook_type> type;
};

template <class BaseHook>
struct any_hook_base_node_traits
{ typedef typename BaseHook::node_traits type; };

template<class T, class BaseHook>
struct get_base_value_traits
{
   typedef typename detail::eval_if_c
      < internal_any_hook_bool_is_true<BaseHook>::value
      , any_hook_base_value_traits<T, BaseHook>
      , concrete_hook_base_value_traits<T, BaseHook>
      >::type type;
};

template<class BaseHook>
struct get_base_node_traits
{
   typedef typename detail::eval_if_c
      < internal_any_hook_bool_is_true<BaseHook>::value
      , any_hook_base_node_traits<BaseHook>
      , concrete_hook_base_node_traits<BaseHook>
      >::type type;
};

template<class T, class MemberHook>
struct get_member_value_traits
{
   typedef typename MemberHook::member_value_traits type;
};

template<class MemberHook>
struct get_member_node_traits
{
   typedef typename MemberHook::member_value_traits::node_traits type;
};

template<class T, class SupposedValueTraits>
struct get_value_traits
{
   typedef typename detail::eval_if_c
      <detail::is_convertible<SupposedValueTraits*, detail::default_hook_tag*>::value
      ,detail::apply<SupposedValueTraits, T>
      ,detail::identity<SupposedValueTraits>
   >::type supposed_value_traits;

   typedef typename detail::eval_if_c
      < internal_base_hook_bool_is_true<supposed_value_traits>::value


      , get_base_value_traits<T, supposed_value_traits>


      , detail::eval_if_c
         < internal_member_value_traits<supposed_value_traits>::value
         , get_member_value_traits<T, supposed_value_traits>
         , detail::identity<supposed_value_traits>
         >
      >::type type;
};

template<class ValueTraits>
struct get_explicit_node_traits
{
   typedef typename ValueTraits::node_traits type;
};

template<class SupposedValueTraits>
struct get_node_traits
{
   typedef SupposedValueTraits supposed_value_traits;

   typedef typename detail::eval_if_c
      < internal_base_hook_bool_is_true<supposed_value_traits>::value


      , get_base_node_traits<supposed_value_traits>


      , detail::eval_if_c
         < internal_member_value_traits<supposed_value_traits>::value
         , get_member_node_traits<supposed_value_traits>
         , get_explicit_node_traits<supposed_value_traits>
         >
      >::type type;
};

}




struct none
{
    template<class Base>
    struct pack : Base
    { };
};






template<bool Enabled>
struct constant_time_size
{

    template<class Base>
    struct pack : Base
    {
        static const bool constant_time_size = Enabled;
    };

};



template<class SizeType>
struct size_type
{

    template<class Base>
    struct pack : Base
    {
        typedef SizeType size_type;
    };

};



template<class Compare>
struct compare
{

    template<class Base>
    struct pack : Base
    {
        typedef Compare compare;
    };

};
# 255 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp"
template<bool Enabled>
struct floating_point
{

    template<class Base>
    struct pack : Base
    {
        static const bool floating_point = Enabled;
    };

};



template<class Equal>
struct equal
{

    template<class Base>
    struct pack : Base
    {
        typedef Equal equal;
    };

};



template<class Priority>
struct priority
{

    template<class Base>
    struct pack : Base
    {
        typedef Priority priority;
    };

};



template<class Hash>
struct hash
{

    template<class Base>
    struct pack : Base
    {
        typedef Hash hash;
    };

};




template<typename ValueTraits>
struct value_traits
{

    template<class Base>
    struct pack : Base
    {
        typedef ValueTraits value_traits;
    };

};



template< typename Parent
        , typename MemberHook
        , MemberHook Parent::* PtrToMember>
struct member_hook
{

   typedef detail::member_hook_traits
      < Parent
      , MemberHook
      , PtrToMember
      > member_value_traits;
   template<class Base>
   struct pack : Base
   {
      typedef member_value_traits value_traits;
   };

};





template< typename Functor>
struct function_hook
{

   typedef detail::function_hook_traits
      <Functor> function_value_traits;
   template<class Base>
   struct pack : Base
   {
      typedef function_value_traits value_traits;
   };

};




template<typename BaseHook>
struct base_hook
{

   template<class Base>
   struct pack : Base
   {
      typedef BaseHook value_traits;
   };

};





template<class VoidPointer>
struct void_pointer
{

   template<class Base>
   struct pack : Base
   {
      typedef VoidPointer void_pointer;
   };

};





template<class Tag>
struct tag
{

   template<class Base>
   struct pack : Base
   {
      typedef Tag tag;
   };

};



template<link_mode_type LinkType>
struct link_mode
{

   template<class Base>
   struct pack : Base
   {
      static const link_mode_type link_mode = LinkType;
   };

};



template<bool Enabled>
struct optimize_size
{

   template<class Base>
   struct pack : Base
   {
      static const bool optimize_size = Enabled;
   };

};



template<bool Enabled>
struct linear
{

   template<class Base>
   struct pack : Base
   {
      static const bool linear = Enabled;
   };

};



template<bool Enabled>
struct cache_last
{

   template<class Base>
   struct pack : Base
   {
      static const bool cache_last = Enabled;
   };

};




template<class BucketTraits>
struct bucket_traits
{

   template<class Base>
   struct pack : Base
   {
      typedef BucketTraits bucket_traits;
   };

};






template<bool Enabled>
struct store_hash
{

    template<class Base>
    struct pack : Base
    {
        static const bool store_hash = Enabled;
    };

};







template<bool Enabled>
struct optimize_multikey
{

    template<class Base>
    struct pack : Base
    {
        static const bool optimize_multikey = Enabled;
    };

};






template<bool Enabled>
struct power_2_buckets
{

   template<class Base>
   struct pack : Base
   {
      static const bool power_2_buckets = Enabled;
   };

};





template<bool Enabled>
struct cache_begin
{

   template<class Base>
   struct pack : Base
   {
      static const bool cache_begin = Enabled;
   };

};
# 556 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp"
template<bool Enabled>
struct compare_hash
{

   template<class Base>
   struct pack : Base
   {
      static const bool compare_hash = Enabled;
   };

};







template<bool Enabled>
struct incremental
{

   template<class Base>
   struct pack : Base
   {
      static const bool incremental = Enabled;
   };

};






template<class Prev, class Next>
struct do_pack
{

   typedef typename Next::template pack<Prev> type;
};

template<class Prev>
struct do_pack<Prev, none>
{

   typedef Prev type;
};

template
   < class DefaultOptions
   , class O1 = none
   , class O2 = none
   , class O3 = none
   , class O4 = none
   , class O5 = none
   , class O6 = none
   , class O7 = none
   , class O8 = none
   , class O9 = none
   , class O10 = none
   , class O11 = none
   >
struct pack_options
{

   typedef
      typename do_pack
      < typename do_pack
         < typename do_pack
            < typename do_pack
               < typename do_pack
                  < typename do_pack
                     < typename do_pack
                        < typename do_pack
                           < typename do_pack
                              < typename do_pack
                                 < typename do_pack
                                    < DefaultOptions
                                    , O1
                                    >::type
                                 , O2
                                 >::type
                              , O3
                              >::type
                           , O4
                           >::type
                        , O5
                        >::type
                     , O6
                     >::type
                  , O7
                  >::type
               , O8
               >::type
            , O9
            >::type
         , O10
         >::type
      , O11
      >::type
   type;
};
# 792 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp"
struct hook_defaults
   : public pack_options
      < none
      , void_pointer<void*>
      , link_mode<safe_link>
      , tag<default_tag>
      , optimize_size<false>
      , store_hash<false>
      , linear<false>
      , optimize_multikey<false>
      >::type
{};



}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 811 "/opt/sevenflow/boost/include/boost/intrusive/options.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/generic_hook.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/generic_hook.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/generic_hook.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/intrusive/detail/generic_hook.hpp"
namespace boost {
namespace intrusive {
namespace detail {



enum
{ NoBaseHook
, ListBaseHook
, SlistBaseHook
, SetBaseHook
, UsetBaseHook
, SplaySetBaseHook
, AvlSetBaseHook
, BsSetBaseHook
, AnyBaseHook
};

struct no_default_definer{};

template <class Hook, unsigned int>
struct default_definer;

template <class Hook>
struct default_definer<Hook, ListBaseHook>
{ typedef Hook default_list_hook; };

template <class Hook>
struct default_definer<Hook, SlistBaseHook>
{ typedef Hook default_slist_hook; };

template <class Hook>
struct default_definer<Hook, SetBaseHook>
{ typedef Hook default_set_hook; };

template <class Hook>
struct default_definer<Hook, UsetBaseHook>
{ typedef Hook default_uset_hook; };

template <class Hook>
struct default_definer<Hook, SplaySetBaseHook>
{ typedef Hook default_splay_set_hook; };

template <class Hook>
struct default_definer<Hook, AvlSetBaseHook>
{ typedef Hook default_avl_set_hook; };

template <class Hook>
struct default_definer<Hook, BsSetBaseHook>
{ typedef Hook default_bs_set_hook; };

template <class Hook>
struct default_definer<Hook, AnyBaseHook>
{ typedef Hook default_any_hook; };

template <class Hook, unsigned int BaseHookType>
struct make_default_definer
{
   typedef typename detail::if_c
      < BaseHookType != 0
      , default_definer<Hook, BaseHookType>
      , no_default_definer>::type type;
};

template
   < class GetNodeAlgorithms
   , class Tag
   , link_mode_type LinkMode
   , int HookType
   >
struct make_node_holder
{
   typedef typename detail::if_c
      <!detail::is_same<Tag, member_tag>::value
      , detail::node_holder
         < typename GetNodeAlgorithms::type::node
         , Tag
         , LinkMode
         , HookType>
      , typename GetNodeAlgorithms::type::node
      >::type type;
};



template
   < class GetNodeAlgorithms
   , class Tag
   , link_mode_type LinkMode
   , int HookType
   >
class generic_hook
# 125 "/opt/sevenflow/boost/include/boost/intrusive/detail/generic_hook.hpp"
   : public make_default_definer
      < generic_hook<GetNodeAlgorithms, Tag, LinkMode, HookType>
      , detail::is_same<Tag, default_tag>::value*HookType
      >::type
   , public make_node_holder<GetNodeAlgorithms, Tag, LinkMode, HookType>::type

{

   typedef typename GetNodeAlgorithms::type node_algorithms;
   typedef typename node_algorithms::node node;
   typedef typename node_algorithms::node_ptr node_ptr;
   typedef typename node_algorithms::const_node_ptr const_node_ptr;

   public:
   struct boost_intrusive_tags
   {
      static const int hook_type = HookType;
      static const link_mode_type link_mode = LinkMode;
      typedef Tag tag;
      typedef typename GetNodeAlgorithms::type::node_traits node_traits;
      static const bool is_base_hook = !detail::is_same<Tag, member_tag>::value;
      static const bool safemode_or_autounlink =
         (int)link_mode == (int)auto_unlink || (int)link_mode == (int)safe_link;
   };

   node_ptr this_ptr()
   { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }

   const_node_ptr this_ptr() const
   { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }

   public:


   generic_hook()
   {
      if(boost_intrusive_tags::safemode_or_autounlink){
         node_algorithms::init(this->this_ptr());
      }
   }

   generic_hook(const generic_hook& )
   {
      if(boost_intrusive_tags::safemode_or_autounlink){
         node_algorithms::init(this->this_ptr());
      }
   }

   generic_hook& operator=(const generic_hook& )
   { return *this; }

   ~generic_hook()
   {
      destructor_impl
         (*this, detail::link_dispatch<boost_intrusive_tags::link_mode>());
   }

   void swap_nodes(generic_hook &other)
   {
      node_algorithms::swap_nodes
         (this->this_ptr(), other.this_ptr());
   }

   bool is_linked() const
   {

      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( boost_intrusive_tags::safemode_or_autounlink )) == 0 ? false : true) >)> boost_static_assert_typedef_191;
      return !node_algorithms::unique(this->this_ptr());
   }

   void unlink()
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( (int)boost_intrusive_tags::link_mode == (int)auto_unlink )) == 0 ? false : true) >)> boost_static_assert_typedef_197;
      node_algorithms::unlink(this->this_ptr());
      node_algorithms::init(this->this_ptr());
   }
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 208 "/opt/sevenflow/boost/include/boost/intrusive/detail/generic_hook.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 2

namespace boost {
namespace intrusive {


template<class VoidPointer, bool OptimizeSize = false>
struct get_set_node_algo
{
   typedef rbtree_algorithms<rbtree_node_traits<VoidPointer, OptimizeSize> > type;
};







template<class O1 = none, class O2 = none, class O3 = none, class O4 = none>

struct make_set_base_hook
{

   typedef typename pack_options
      < hook_defaults,

      O1, O2, O3, O4



      >::type packed_options;

   typedef detail::generic_hook
   < get_set_node_algo<typename packed_options::void_pointer
                      ,packed_options::optimize_size>
   , typename packed_options::tag
   , packed_options::link_mode
   , detail::SetBaseHook
   > implementation_defined;

   typedef implementation_defined type;
};
# 89 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp"
template<class O1, class O2, class O3, class O4>

class set_base_hook
   : public make_set_base_hook<

      O1, O2, O3, O4



      >::type
{
# 166 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp"
};






template<class O1 = none, class O2 = none, class O3 = none, class O4 = none>

struct make_set_member_hook
{

   typedef typename pack_options
      < hook_defaults,

      O1, O2, O3, O4



      >::type packed_options;

   typedef detail::generic_hook
   < get_set_node_algo<typename packed_options::void_pointer
                      ,packed_options::optimize_size>
   , member_tag
   , packed_options::link_mode
   , detail::NoBaseHook
   > implementation_defined;

   typedef implementation_defined type;
};
# 216 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp"
template<class O1, class O2, class O3, class O4>

class set_member_hook
   : public make_set_member_hook<

      O1, O2, O3, O4



      >::type
{
# 293 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp"
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 299 "/opt/sevenflow/boost/include/boost/intrusive/set_hook.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_node.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_node.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_node.hpp" 2




namespace boost {
namespace intrusive {

template<class VoidPointer>
struct tree_node
{
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer
         <tree_node<VoidPointer> >::type node_ptr;

   node_ptr parent_, left_, right_;
};

template<class VoidPointer>
struct tree_node_traits
{
   typedef tree_node<VoidPointer> node;

   typedef typename pointer_traits<VoidPointer>::template
      rebind_pointer<node>::type node_ptr;
   typedef typename pointer_traits<VoidPointer>::template
      rebind_pointer<const node>::type const_node_ptr;

   static const node_ptr & get_parent(const const_node_ptr & n)
   { return n->parent_; }

   static void set_parent(const node_ptr & n, const node_ptr & p)
   { n->parent_ = p; }

   static const node_ptr & get_left(const const_node_ptr & n)
   { return n->left_; }

   static void set_left(const node_ptr & n, const node_ptr & l)
   { n->left_ = l; }

   static const node_ptr & get_right(const const_node_ptr & n)
   { return n->right_; }

   static void set_right(const node_ptr & n, const node_ptr & r)
   { n->right_ = r; }
};
# 71 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_node.hpp"
template<class Container, bool IsConst>
class tree_iterator
   : public std::iterator
         < std::bidirectional_iterator_tag
         , typename Container::value_type
         , typename Container::difference_type
         , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type
         , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type
         >
{
   protected:
   typedef typename Container::real_value_traits real_value_traits;
   typedef typename Container::node_algorithms node_algorithms;
   typedef typename real_value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename pointer_traits<node_ptr>::template
      rebind_pointer<void>::type void_pointer;
   static const bool store_container_ptr =
      detail::store_cont_ptr_on_it<Container>::value;

   public:
   typedef typename Container::value_type value_type;
   typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer;
   typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;


   tree_iterator()
      : members_ (node_ptr(), (const void *)0)
   {}

   explicit tree_iterator(const node_ptr & nodeptr, const Container *cont_ptr)
      : members_ (nodeptr, cont_ptr)
   {}

   tree_iterator(tree_iterator<Container, false> const& other)
      : members_(other.pointed_node(), other.get_container())
   {}

   const node_ptr &pointed_node() const
   { return members_.nodeptr_; }

   tree_iterator &operator=(const node_ptr &nodeptr)
   { members_.nodeptr_ = nodeptr; return static_cast<tree_iterator&>(*this); }

   public:
   tree_iterator& operator++()
   {
      members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   tree_iterator operator++(int)
   {
      tree_iterator result (*this);
      members_.nodeptr_ = node_algorithms::next_node(members_.nodeptr_);
      return result;
   }

   tree_iterator& operator--()
   {
      members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
      return static_cast<tree_iterator&> (*this);
   }

   tree_iterator operator--(int)
   {
      tree_iterator result (*this);
      members_.nodeptr_ = node_algorithms::prev_node(members_.nodeptr_);
      return result;
   }

   friend bool operator== (const tree_iterator& l, const tree_iterator& r)
   { return l.pointed_node() == r.pointed_node(); }

   friend bool operator!= (const tree_iterator& l, const tree_iterator& r)
   { return !(l == r); }

   reference operator*() const
   { return *operator->(); }

   pointer operator->() const
   { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); }

   const Container *get_container() const
   { return static_cast<const Container*>(members_.get_ptr()); }

   const real_value_traits *get_real_value_traits() const
   { return &this->get_container()->get_real_value_traits(); }

   tree_iterator end_iterator_from_it() const
   {
      return tree_iterator(node_algorithms::get_header(this->pointed_node()), this->get_container());
   }

   tree_iterator<Container, false> unconst() const
   { return tree_iterator<Container, false>(this->pointed_node(), this->get_container()); }

   private:
   struct members
      : public detail::select_constptr
         <void_pointer, store_container_ptr>::type
   {
      typedef typename detail::select_constptr
         <void_pointer, store_container_ptr>::type Base;

      members(const node_ptr &n_ptr, const void *cont)
         : Base(cont), nodeptr_(n_ptr)
      {}

      node_ptr nodeptr_;
   } members_;
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 189 "/opt/sevenflow/boost/include/boost/intrusive/detail/tree_node.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/clear_on_destructor_base.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/intrusive/detail/clear_on_destructor_base.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/intrusive/detail/clear_on_destructor_base.hpp" 2

namespace boost {
namespace intrusive {
namespace detail {

template<class Derived>
class clear_on_destructor_base
{
   protected:
   ~clear_on_destructor_base()
   {
      static_cast<Derived*>(this)->clear();
   }
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 35 "/opt/sevenflow/boost/include/boost/intrusive/detail/clear_on_destructor_base.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2







namespace boost {
namespace intrusive {



template <class ValueTraits, class Compare, class SizeType, bool ConstantTimeSize>
struct setopt
{
   typedef ValueTraits value_traits;
   typedef Compare compare;
   typedef SizeType size_type;
   static const bool constant_time_size = ConstantTimeSize;
};

template <class T>
struct set_defaults
   : pack_options
      < none
      , base_hook<detail::default_set_hook>
      , constant_time_size<true>
      , size_type<std::size_t>
      , compare<std::less<T> >
      >::type
{};
# 82 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
template<class Config>

class rbtree_impl
   : private detail::clear_on_destructor_base<rbtree_impl<Config> >
{
   template<class C> friend class detail::clear_on_destructor_base;
   public:
   typedef typename Config::value_traits value_traits;

   static const bool external_value_traits =
      detail::external_value_traits_is_true<value_traits>::value;
   typedef typename detail::eval_if_c
      < external_value_traits
      , detail::eval_value_traits<value_traits>
      , detail::identity<value_traits>
      >::type real_value_traits;

   typedef typename real_value_traits::pointer pointer;
   typedef typename real_value_traits::const_pointer const_pointer;

   typedef typename pointer_traits<pointer>::element_type value_type;
   typedef value_type key_type;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits<const_pointer>::reference const_reference;
   typedef typename pointer_traits<const_pointer>::difference_type difference_type;
   typedef typename Config::size_type size_type;
   typedef typename Config::compare value_compare;
   typedef value_compare key_compare;
   typedef tree_iterator<rbtree_impl, false> iterator;
   typedef tree_iterator<rbtree_impl, true> const_iterator;
   typedef boost::intrusive::detail::reverse_iterator<iterator> reverse_iterator;
   typedef boost::intrusive::detail::reverse_iterator<const_iterator>const_reverse_iterator;
   typedef typename real_value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef rbtree_algorithms<node_traits> node_algorithms;

   static const bool constant_time_size = Config::constant_time_size;
   static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;

   private:
   typedef detail::size_holder<constant_time_size, size_type> size_traits;


   private: rbtree_impl(rbtree_impl &); rbtree_impl& operator=(rbtree_impl &); public: operator ::boost::rv<rbtree_impl>&() { return *static_cast< ::boost::rv<rbtree_impl>* >(this); } operator const ::boost::rv<rbtree_impl>&() const { return *static_cast<const ::boost::rv<rbtree_impl>* >(this); } private:

   enum { safemode_or_autounlink =
            (int)real_value_traits::link_mode == (int)auto_unlink ||
            (int)real_value_traits::link_mode == (int)safe_link };


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))) == 0 ? false : true) >)> boost_static_assert_typedef_134;

   struct header_plus_size : public size_traits
   { node header_; };

   struct node_plus_pred_t : public detail::ebo_functor_holder<value_compare>
   {
      node_plus_pred_t(const value_compare &comp)
         : detail::ebo_functor_holder<value_compare>(comp)
      {}
      header_plus_size header_plus_size_;
   };

   struct data_t : public rbtree_impl::value_traits
   {
      typedef typename rbtree_impl::value_traits value_traits;
      data_t(const value_compare & comp, const value_traits &val_traits)
         : value_traits(val_traits), node_plus_pred_(comp)
      {}
      node_plus_pred_t node_plus_pred_;
   } data_;

   const value_compare &priv_comp() const
   { return data_.node_plus_pred_.get(); }

   value_compare &priv_comp()
   { return data_.node_plus_pred_.get(); }

   const value_traits &priv_value_traits() const
   { return data_; }

   value_traits &priv_value_traits()
   { return data_; }

   node_ptr priv_header_ptr()
   { return pointer_traits<node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

   const_node_ptr priv_header_ptr() const
   { return pointer_traits<const_node_ptr>::pointer_to(data_.node_plus_pred_.header_plus_size_.header_); }

   static node_ptr uncast(const const_node_ptr & ptr)
   { return pointer_traits<node_ptr>::const_cast_from(ptr); }

   size_traits &priv_size_traits()
   { return data_.node_plus_pred_.header_plus_size_; }

   const size_traits &priv_size_traits() const
   { return data_.node_plus_pred_.header_plus_size_; }

   const real_value_traits &get_real_value_traits(detail::bool_<false>) const
   { return data_; }

   const real_value_traits &get_real_value_traits(detail::bool_<true>) const
   { return data_.get_value_traits(*this); }

   real_value_traits &get_real_value_traits(detail::bool_<false>)
   { return data_; }

   real_value_traits &get_real_value_traits(detail::bool_<true>)
   { return data_.get_value_traits(*this); }

   protected:
   value_compare &prot_comp()
   { return priv_comp(); }

   const node &prot_header_node() const
   { return data_.node_plus_pred_.header_plus_size_.header_; }

   node &prot_header_node()
   { return data_.node_plus_pred_.header_plus_size_.header_; }

   void prot_set_size(size_type s)
   { this->priv_size_traits().set_size(s); }



   public:

   const real_value_traits &get_real_value_traits() const
   { return this->get_real_value_traits(detail::bool_<external_value_traits>()); }

   real_value_traits &get_real_value_traits()
   { return this->get_real_value_traits(detail::bool_<external_value_traits>()); }

   typedef typename node_algorithms::insert_commit_data insert_commit_data;
# 227 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   rbtree_impl( const value_compare &cmp = value_compare()
              , const value_traits &v_traits = value_traits())
      : data_(cmp, v_traits)
   {
      node_algorithms::init_header(this->priv_header_ptr());
      this->priv_size_traits().set_size(size_type(0));
   }
# 247 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Iterator>
   rbtree_impl( bool unique, Iterator b, Iterator e
              , const value_compare &cmp = value_compare()
              , const value_traits &v_traits = value_traits())
      : data_(cmp, v_traits)
   {
      node_algorithms::init_header(this->priv_header_ptr());
      this->priv_size_traits().set_size(size_type(0));
      if(unique)
         this->insert_unique(b, e);
      else
         this->insert_equal(b, e);
   }



   rbtree_impl(::boost::rv< rbtree_impl >& x)
      : data_(::boost::move(x.priv_comp()), ::boost::move(x.priv_value_traits()))
   {
      node_algorithms::init_header(this->priv_header_ptr());
      this->priv_size_traits().set_size(size_type(0));
      this->swap(x);
   }



   rbtree_impl& operator=(::boost::rv< rbtree_impl >& x)
   { this->swap(x); return *this; }
# 283 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   ~rbtree_impl()
   {}






   iterator begin()
   { return iterator (node_traits::get_left(this->priv_header_ptr()), this); }






   const_iterator begin() const
   { return cbegin(); }






   const_iterator cbegin() const
   { return const_iterator (node_traits::get_left(this->priv_header_ptr()), this); }






   iterator end()
   { return iterator (this->priv_header_ptr(), this); }






   const_iterator end() const
   { return cend(); }






   const_iterator cend() const
   { return const_iterator (uncast(this->priv_header_ptr()), this); }







   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()); }
# 396 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static rbtree_impl &container_from_end_iterator(iterator end_iterator)
   { return priv_container_from_end_iterator(end_iterator); }
# 407 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static const rbtree_impl &container_from_end_iterator(const_iterator end_iterator)
   { return priv_container_from_end_iterator(end_iterator); }
# 418 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static rbtree_impl &container_from_iterator(iterator it)
   { return priv_container_from_iterator(it); }
# 429 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static const rbtree_impl &container_from_iterator(const_iterator it)
   { return priv_container_from_iterator(it); }






   value_compare value_comp() const
   { return priv_comp(); }






   bool empty() const
   { return node_algorithms::unique(this->priv_header_ptr()); }







   size_type size() const
   {
      if(constant_time_size)
         return this->priv_size_traits().get_size();
      else{
         return (size_type)node_algorithms::size(this->priv_header_ptr());
      }
   }






   void swap(rbtree_impl& other)
   {

      using std::swap;
      swap(priv_comp(), priv_comp());

      node_algorithms::swap_tree(this->priv_header_ptr(), node_ptr(other.priv_header_ptr()));
      if(constant_time_size){
         size_type backup = this->priv_size_traits().get_size();
         this->priv_size_traits().set_size(other.priv_size_traits().get_size());
         other.priv_size_traits().set_size(backup);
      }
   }
# 493 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator insert_equal(reference value)
   {
      detail::key_nodeptr_comp<value_compare, rbtree_impl>
         key_node_comp(priv_comp(), this);
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         ((node_algorithms::unique(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 499, __PRETTY_FUNCTION__));
      iterator ret(node_algorithms::insert_equal_upper_bound
         (this->priv_header_ptr(), to_insert, key_node_comp), this);
      this->priv_size_traits().increment();
      return ret;
   }
# 520 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator insert_equal(const_iterator hint, reference value)
   {
      detail::key_nodeptr_comp<value_compare, rbtree_impl>
         key_node_comp(priv_comp(), this);
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         ((node_algorithms::unique(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 526, __PRETTY_FUNCTION__));
      iterator ret(node_algorithms::insert_equal
         (this->priv_header_ptr(), hint.pointed_node(), to_insert, key_node_comp), this);
      this->priv_size_traits().increment();
      return ret;
   }
# 547 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Iterator>
   void insert_equal(Iterator b, Iterator e)
   {
      iterator iend(this->end());
      for (; b != e; ++b)
         this->insert_equal(iend, *b);
   }
# 567 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   std::pair<iterator, bool> insert_unique(reference value)
   {
      insert_commit_data commit_data;
      std::pair<iterator, bool> ret = insert_unique_check(value, priv_comp(), commit_data);
      if(!ret.second)
         return ret;
      return std::pair<iterator, bool> (insert_unique_commit(value, commit_data), true);
   }
# 590 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator insert_unique(const_iterator hint, reference value)
   {
      insert_commit_data commit_data;
      std::pair<iterator, bool> ret = insert_unique_check(hint, value, priv_comp(), commit_data);
      if(!ret.second)
         return ret.first;
      return insert_unique_commit(value, commit_data);
   }
# 612 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Iterator>
   void insert_unique(Iterator b, Iterator e)
   {
      if(this->empty()){
         iterator iend(this->end());
         for (; b != e; ++b)
            this->insert_unique(iend, *b);
      }
      else{
         for (; b != e; ++b)
            this->insert_unique(*b);
      }
   }
# 656 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator, bool> insert_unique_check
      (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         comp(key_value_comp, this);
      std::pair<node_ptr, bool> ret =
         (node_algorithms::insert_unique_check
            (this->priv_header_ptr(), key, comp, commit_data));
      return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
   }
# 700 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator, bool> insert_unique_check
      (const_iterator hint, const KeyType &key
      ,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         comp(key_value_comp, this);
      std::pair<node_ptr, bool> ret =
         (node_algorithms::insert_unique_check
            (this->priv_header_ptr(), hint.pointed_node(), key, comp, commit_data));
      return std::pair<iterator, bool>(iterator(ret.first, this), ret.second);
   }
# 730 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator insert_unique_commit(reference value, const insert_commit_data &commit_data)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         ((node_algorithms::unique(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 734, __PRETTY_FUNCTION__));
      node_algorithms::insert_unique_commit
               (this->priv_header_ptr(), to_insert, commit_data);
      this->priv_size_traits().increment();
      return iterator(to_insert, this);
   }
# 755 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator insert_before(const_iterator pos, reference value)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         ((node_algorithms::unique(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 759, __PRETTY_FUNCTION__));
      this->priv_size_traits().increment();
      return iterator(node_algorithms::insert_before
         (this->priv_header_ptr(), pos.pointed_node(), to_insert), this);
   }
# 779 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   void push_back(reference value)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         ((node_algorithms::unique(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 783, __PRETTY_FUNCTION__));
      this->priv_size_traits().increment();
      node_algorithms::push_back(this->priv_header_ptr(), to_insert);
   }
# 802 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   void push_front(reference value)
   {
      node_ptr to_insert(get_real_value_traits().to_node_ptr(value));
      if(safemode_or_autounlink)
         ((node_algorithms::unique(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::unique(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 806, __PRETTY_FUNCTION__));
      this->priv_size_traits().increment();
      node_algorithms::push_front(this->priv_header_ptr(), to_insert);
   }
# 819 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator erase(const_iterator i)
   {
      const_iterator ret(i);
      ++ret;
      node_ptr to_erase(i.pointed_node());
      if(safemode_or_autounlink)
         ((!node_algorithms::unique(to_erase)) ? static_cast<void> (0) : __assert_fail ("!node_algorithms::unique(to_erase)", "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp", 825, __PRETTY_FUNCTION__));
      node_algorithms::erase(this->priv_header_ptr(), to_erase);
      this->priv_size_traits().decrement();
      if(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      return ret.unconst();
   }
# 842 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator erase(const_iterator b, const_iterator e)
   { size_type n; return private_erase(b, e, n); }
# 855 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   size_type erase(const_reference value)
   { return this->erase(value, priv_comp()); }
# 869 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   size_type erase(const KeyType& key, KeyValueCompare comp

                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0

                  )
   {
      std::pair<iterator,iterator> p = this->equal_range(key, comp);
      size_type n;
      private_erase(p.first, p.second, n);
      return n;
   }
# 893 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer)
   {
      node_ptr to_erase(i.pointed_node());
      iterator ret(this->erase(i));
      disposer(get_real_value_traits().to_value_ptr(to_erase));
      return ret;
   }


   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer)
   { return this->erase_and_dispose(const_iterator(i), disposer); }
# 921 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Disposer>
   size_type erase_and_dispose(const_reference value, Disposer disposer)
   {
      std::pair<iterator,iterator> p = this->equal_range(value);
      size_type n;
      private_erase(p.first, p.second, n, disposer);
      return n;
   }
# 942 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
   { size_type n; return private_erase(b, e, n, disposer); }
# 960 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare, class Disposer>
   size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer

                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0

                  )
   {
      std::pair<iterator,iterator> p = this->equal_range(key, comp);
      size_type n;
      private_erase(p.first, p.second, n, disposer);
      return n;
   }
# 982 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   void clear()
   {
      if(safemode_or_autounlink){
         this->clear_and_dispose(detail::null_disposer());
      }
      else{
         node_algorithms::init_header(this->priv_header_ptr());
         this->priv_size_traits().set_size(0);
      }
   }
# 1002 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class Disposer>
   void clear_and_dispose(Disposer disposer)
   {
      node_algorithms::clear_and_dispose(this->priv_header_ptr()
         , detail::node_disposer<Disposer, rbtree_impl>(disposer, this));
      node_algorithms::init_header(this->priv_header_ptr());
      this->priv_size_traits().set_size(0);
   }







   size_type count(const_reference value) const
   { return this->count(value, priv_comp()); }







   template<class KeyType, class KeyValueCompare>
   size_type count(const KeyType &key, KeyValueCompare comp) const
   {
      std::pair<const_iterator, const_iterator> ret = this->equal_range(key, comp);
      return std::distance(ret.first, ret.second);
   }







   iterator lower_bound(const_reference value)
   { return this->lower_bound(value, priv_comp()); }







   const_iterator lower_bound(const_reference value) const
   { return this->lower_bound(value, priv_comp()); }







   template<class KeyType, class KeyValueCompare>
   iterator lower_bound(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return iterator(node_algorithms::lower_bound
         (this->priv_header_ptr(), key, key_node_comp), this);
   }







   template<class KeyType, class KeyValueCompare>
   const_iterator lower_bound(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return const_iterator(node_algorithms::lower_bound
         (this->priv_header_ptr(), key, key_node_comp), this);
   }







   iterator upper_bound(const_reference value)
   { return this->upper_bound(value, priv_comp()); }
# 1097 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator upper_bound(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return iterator(node_algorithms::upper_bound
         (this->priv_header_ptr(), key, key_node_comp), this);
   }







   const_iterator upper_bound(const_reference value) const
   { return this->upper_bound(value, priv_comp()); }
# 1122 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator upper_bound(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return const_iterator(node_algorithms::upper_bound
         (this->priv_header_ptr(), key, key_node_comp), this);
   }







   iterator find(const_reference value)
   { return this->find(value, priv_comp()); }







   template<class KeyType, class KeyValueCompare>
   iterator find(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return iterator
         (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
   }







   const_iterator find(const_reference value) const
   { return this->find(value, priv_comp()); }







   template<class KeyType, class KeyValueCompare>
   const_iterator find(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      return const_iterator
         (node_algorithms::find(this->priv_header_ptr(), key, key_node_comp), this);
   }
# 1186 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   std::pair<iterator,iterator> equal_range(const_reference value)
   { return this->equal_range(value, priv_comp()); }
# 1196 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> equal_range(const KeyType &key, KeyValueCompare comp)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
      return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
   }
# 1213 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   std::pair<const_iterator, const_iterator>
      equal_range(const_reference value) const
   { return this->equal_range(value, priv_comp()); }
# 1224 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType &key, KeyValueCompare comp) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::equal_range(this->priv_header_ptr(), key, key_node_comp));
      return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
   }
# 1250 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   std::pair<iterator,iterator> bounded_range
      (const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed)
   { return this->bounded_range(lower_value, upper_value, priv_comp(), left_closed, right_closed); }
# 1272 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> bounded_range
      (const KeyType &lower_key, const KeyType &upper_key, KeyValueCompare comp, bool left_closed, bool right_closed)
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::bounded_range
            (this->priv_header_ptr(), lower_key, upper_key, key_node_comp, left_closed, right_closed));
      return std::pair<iterator, iterator>(iterator(ret.first, this), iterator(ret.second, this));
   }
# 1299 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   std::pair<const_iterator,const_iterator> bounded_range
      (const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const
   { return this->bounded_range(lower_value, upper_value, priv_comp(), left_closed, right_closed); }
# 1321 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator,const_iterator> bounded_range
      (const KeyType &lower_key, const KeyType &upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const
   {
      detail::key_nodeptr_comp<KeyValueCompare, rbtree_impl>
         key_node_comp(comp, this);
      std::pair<node_ptr, node_ptr> ret
         (node_algorithms::bounded_range
            (this->priv_header_ptr(), lower_key, upper_key, key_node_comp, left_closed, right_closed));
      return std::pair<const_iterator, const_iterator>(const_iterator(ret.first, this), const_iterator(ret.second, this));
   }
# 1347 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   template <class Cloner, class Disposer>
   void clone_from(const rbtree_impl &src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      if(!src.empty()){
         detail::exception_disposer<rbtree_impl, Disposer>
            rollback(*this, disposer);
         node_algorithms::clone
            (const_node_ptr(src.priv_header_ptr())
            ,node_ptr(this->priv_header_ptr())
            ,detail::node_cloner<Cloner, rbtree_impl>(cloner, this)
            ,detail::node_disposer<Disposer, rbtree_impl>(disposer, this));
         this->priv_size_traits().set_size(src.priv_size_traits().get_size());
         this->priv_comp() = src.priv_comp();
         rollback.release();
      }
   }
# 1375 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   pointer unlink_leftmost_without_rebalance()
   {
      node_ptr to_be_disposed(node_algorithms::unlink_leftmost_without_rebalance
                           (this->priv_header_ptr()));
      if(!to_be_disposed)
         return 0;
      this->priv_size_traits().decrement();
      if(safemode_or_autounlink)
         node_algorithms::init(to_be_disposed);
      return get_real_value_traits().to_value_ptr(to_be_disposed);
   }
# 1401 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   void replace_node(iterator replace_this, reference with_this)
   {
      node_algorithms::replace_node( get_real_value_traits().to_node_ptr(*replace_this)
                                   , this->priv_header_ptr()
                                   , get_real_value_traits().to_node_ptr(with_this));
      if(safemode_or_autounlink)
         node_algorithms::init(replace_this.pointed_node());
   }
# 1422 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static iterator s_iterator_to(reference value)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!stateful_value_traits)) == 0 ? false : true) >)> boost_static_assert_typedef_1424;
      return iterator (value_traits::to_node_ptr(value), 0);
   }
# 1440 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static const_iterator s_iterator_to(const_reference value)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!stateful_value_traits)) == 0 ? false : true) >)> boost_static_assert_typedef_1442;
      return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
   }
# 1455 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   iterator iterator_to(reference value)
   { return iterator (value_traits::to_node_ptr(value), this); }
# 1467 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   const_iterator iterator_to(const_reference value) const
   { return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this); }
# 1481 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static void init_node(reference value)
   { node_algorithms::init(value_traits::to_node_ptr(value)); }
# 1496 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp"
   static void remove_node(reference value)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!constant_time_size)) == 0 ? false : true) >)> boost_static_assert_typedef_1498;
      node_ptr to_remove(value_traits::to_node_ptr(value));
      node_algorithms::unlink(to_remove);
      if(safemode_or_autounlink)
         node_algorithms::init(to_remove);
   }


   private:
   template<class Disposer>
   iterator private_erase(const_iterator b, const_iterator e, size_type &n, Disposer disposer)
   {
      for(n = 0; b != e; ++n)
        this->erase_and_dispose(b++, disposer);
      return b.unconst();
   }

   iterator private_erase(const_iterator b, const_iterator e, size_type &n)
   {
      for(n = 0; b != e; ++n)
        this->erase(b++);
      return b.unconst();
   }


   private:
   static rbtree_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
   {
      header_plus_size *r = detail::parent_from_member<header_plus_size, node>
         ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), &header_plus_size::header_);
      node_plus_pred_t *n = detail::parent_from_member
         <node_plus_pred_t, header_plus_size>(r, &node_plus_pred_t::header_plus_size_);
      data_t *d = detail::parent_from_member<data_t, node_plus_pred_t>(n, &data_t::node_plus_pred_);
      rbtree_impl *rb = detail::parent_from_member<rbtree_impl, data_t>(d, &rbtree_impl::data_);
      return *rb;
   }

   static rbtree_impl &priv_container_from_iterator(const const_iterator &it)
   { return priv_container_from_end_iterator(it.end_iterator_from_it()); }
};




template<class Config>

inline bool operator<



(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)

{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }




template<class Config>

bool operator==



(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)

{
   typedef rbtree_impl<Config> tree_type;
   typedef typename tree_type::const_iterator const_iterator;

   if(tree_type::constant_time_size && x.size() != y.size()){
      return false;
   }
   const_iterator end1 = x.end();
   const_iterator i1 = x.begin();
   const_iterator i2 = y.begin();
   if(tree_type::constant_time_size){
      while (i1 != end1 && *i1 == *i2) {
         ++i1;
         ++i2;
      }
      return i1 == end1;
   }
   else{
      const_iterator end2 = y.end();
      while (i1 != end1 && i2 != end2 && *i1 == *i2) {
         ++i1;
         ++i2;
      }
      return i1 == end1 && i2 == end2;
   }
}




template<class Config>

inline bool operator!=



(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)

{ return !(x == y); }




template<class Config>

inline bool operator>



(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)

{ return y < x; }




template<class Config>

inline bool operator<=



(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)

{ return !(y < x); }




template<class Config>

inline bool operator>=



(const rbtree_impl<Config> &x, const rbtree_impl<Config> &y)

{ return !(x < y); }




template<class Config>

inline void swap



(rbtree_impl<Config> &x, rbtree_impl<Config> &y)

{ x.swap(y); }



template<class T, class O1 = none, class O2 = none
                , class O3 = none, class O4 = none
                >



struct make_rbtree_opt
{
   typedef typename pack_options
      < set_defaults<T>,

      O1, O2, O3, O4



      >::type packed_options;
   typedef typename detail::get_value_traits
      <T, typename packed_options::value_traits>::type value_traits;

   typedef setopt
         < value_traits
         , typename packed_options::compare
         , typename packed_options::size_type
         , packed_options::constant_time_size
         > type;
};







template<class T, class O1 = none, class O2 = none
                , class O3 = none, class O4 = none>

struct make_rbtree
{

   typedef rbtree_impl
      < typename make_rbtree_opt<T,

         O1, O2, O3, O4



         >::type
      > implementation_defined;

   typedef implementation_defined type;
};




template<class T, class O1, class O2, class O3, class O4>



class rbtree
   : public make_rbtree<T,

      O1, O2, O3, O4



      >::type
{
   typedef typename make_rbtree
      <T,

      O1, O2, O3, O4



      >::type Base;
   private: rbtree(rbtree &); rbtree& operator=(rbtree &); public: operator ::boost::rv<rbtree>&() { return *static_cast< ::boost::rv<rbtree>* >(this); } operator const ::boost::rv<rbtree>&() const { return *static_cast<const ::boost::rv<rbtree>* >(this); } private:

   public:
   typedef typename Base::value_compare value_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::real_value_traits real_value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((detail::is_same<typename real_value_traits::value_type, T>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_1743;

   rbtree( const value_compare &cmp = value_compare()
         , const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   rbtree( bool unique, Iterator b, Iterator e
         , const value_compare &cmp = value_compare()
         , const value_traits &v_traits = value_traits())
      : Base(unique, b, e, cmp, v_traits)
   {}

   rbtree(::boost::rv< rbtree >& x)
      : Base(::boost::move(static_cast<Base&>(x)))
   {}

   rbtree& operator=(::boost::rv< rbtree >& x)
   { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }

   static rbtree &container_from_end_iterator(iterator end_iterator)
   { return static_cast<rbtree &>(Base::container_from_end_iterator(end_iterator)); }

   static const rbtree &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const rbtree &>(Base::container_from_end_iterator(end_iterator)); }

   static rbtree &container_from_it(iterator it)
   { return static_cast<rbtree &>(Base::container_from_iterator(it)); }

   static const rbtree &container_from_it(const_iterator it)
   { return static_cast<const rbtree &>(Base::container_from_iterator(it)); }
};




}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 1784 "/opt/sevenflow/boost/include/boost/intrusive/rbtree.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp" 2



namespace boost {
namespace intrusive {
# 40 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
template<class Config>

class set_impl
{

   typedef rbtree_impl<Config> tree_type;
   private: set_impl(set_impl &); set_impl& operator=(set_impl &); public: operator ::boost::rv<set_impl>&() { return *static_cast< ::boost::rv<set_impl>* >(this); } operator const ::boost::rv<set_impl>&() const { return *static_cast<const ::boost::rv<set_impl>* >(this); } private:

   typedef tree_type implementation_defined;


   public:
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::value_traits value_traits;
   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::insert_commit_data insert_commit_data;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = Config::constant_time_size;



   private:
   tree_type tree_;

   protected:
   node &prot_header_node(){ return tree_.prot_header_node(); }
   node const &prot_header_node() const{ return tree_.prot_header_node(); }
   void prot_set_size(size_type s){ tree_.prot_set_size(s); }
   value_compare &prot_comp(){ return tree_.prot_comp(); }



   public:







   set_impl( const value_compare &cmp = value_compare()
           , const value_traits &v_traits = value_traits())
      : tree_(cmp, v_traits)
   {}
# 113 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Iterator>
   set_impl( Iterator b, Iterator e
           , const value_compare &cmp = value_compare()
           , const value_traits &v_traits = value_traits())
      : tree_(true, b, e, cmp, v_traits)
   {}



   set_impl(::boost::rv< set_impl >& x)
      : tree_(::boost::move(x.tree_))
   {}



   set_impl& operator=(::boost::rv< set_impl >& x)
   { tree_ = ::boost::move(x.tree_); return *this; }
# 138 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   ~set_impl()
   {}






   iterator begin()
   { return tree_.begin(); }






   const_iterator begin() const
   { return tree_.begin(); }






   const_iterator cbegin() const
   { return tree_.cbegin(); }






   iterator end()
   { return tree_.end(); }






   const_iterator end() const
   { return tree_.end(); }






   const_iterator cend() const
   { return tree_.cend(); }







   reverse_iterator rbegin()
   { return tree_.rbegin(); }







   const_reverse_iterator rbegin() const
   { return tree_.rbegin(); }







   const_reverse_iterator crbegin() const
   { return tree_.crbegin(); }







   reverse_iterator rend()
   { return tree_.rend(); }







   const_reverse_iterator rend() const
   { return tree_.rend(); }







   const_reverse_iterator crend() const
   { return tree_.crend(); }
# 251 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static set_impl &container_from_end_iterator(iterator end_iterator)
   {
      return *detail::parent_from_member<set_impl, tree_type>
         ( &tree_type::container_from_end_iterator(end_iterator)
         , &set_impl::tree_);
   }
# 266 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static const set_impl &container_from_end_iterator(const_iterator end_iterator)
   {
      return *detail::parent_from_member<set_impl, tree_type>
         ( &tree_type::container_from_end_iterator(end_iterator)
         , &set_impl::tree_);
   }
# 280 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static set_impl &container_from_iterator(iterator it)
   {
      return *detail::parent_from_member<set_impl, tree_type>
         ( &tree_type::container_from_iterator(it)
         , &set_impl::tree_);
   }
# 294 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static const set_impl &container_from_iterator(const_iterator it)
   {
      return *detail::parent_from_member<set_impl, tree_type>
         ( &tree_type::container_from_iterator(it)
         , &set_impl::tree_);
   }






   key_compare key_comp() const
   { return tree_.value_comp(); }






   value_compare value_comp() const
   { return tree_.value_comp(); }






   bool empty() const
   { return tree_.empty(); }







   size_type size() const
   { return tree_.size(); }







   void swap(set_impl& other)
   { tree_.swap(other.tree_); }
# 357 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template <class Cloner, class Disposer>
   void clone_from(const set_impl &src, Cloner cloner, Disposer disposer)
   { tree_.clone_from(src.tree_, cloner, disposer); }
# 378 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<iterator, bool> insert(reference value)
   { return tree_.insert_unique(value); }
# 396 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator insert(const_iterator hint, reference value)
   { return tree_.insert_unique(hint, value); }
# 429 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator, bool> insert_check
      (const KeyType &key, KeyValueCompare key_value_comp, insert_commit_data &commit_data)
   { return tree_.insert_unique_check(key, key_value_comp, commit_data); }
# 466 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator, bool> insert_check
      (const_iterator hint, const KeyType &key
      ,KeyValueCompare key_value_comp, insert_commit_data &commit_data)
   { return tree_.insert_unique_check(hint, key, key_value_comp, commit_data); }
# 489 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator insert_commit(reference value, const insert_commit_data &commit_data)
   { return tree_.insert_unique_commit(value, commit_data); }
# 505 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Iterator>
   void insert(Iterator b, Iterator e)
   { tree_.insert_unique(b, e); }
# 525 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator insert_before(const_iterator pos, reference value)
   { return tree_.insert_before(pos, value); }
# 542 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void push_back(reference value)
   { tree_.push_back(value); }
# 560 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void push_front(reference value)
   { tree_.push_front(value); }
# 573 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator erase(const_iterator i)
   { return tree_.erase(i); }
# 587 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator erase(const_iterator b, const_iterator e)
   { return tree_.erase(b, e); }
# 600 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   size_type erase(const_reference value)
   { return tree_.erase(value); }
# 614 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   size_type erase(const KeyType& key, KeyValueCompare comp

                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0

                  )
   { return tree_.erase(key, comp); }
# 635 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer)
   { return tree_.erase_and_dispose(i, disposer); }


   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer)
   { return this->erase_and_dispose(const_iterator(i), disposer); }
# 659 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
   { return tree_.erase_and_dispose(b, e, disposer); }
# 676 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   size_type erase_and_dispose(const_reference value, Disposer disposer)
   { return tree_.erase_and_dispose(value, disposer); }
# 694 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare, class Disposer>
   size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer

                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0

                  )
   { return tree_.erase_and_dispose(key, comp, disposer); }
# 711 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void clear()
   { return tree_.clear(); }
# 725 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   void clear_and_dispose(Disposer disposer)
   { return tree_.clear_and_dispose(disposer); }







   size_type count(const_reference value) const
   { return tree_.find(value) != end(); }
# 745 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   size_type count(const KeyType& key, KeyValueCompare comp) const
   { return tree_.find(key, comp) != end(); }







   iterator lower_bound(const_reference value)
   { return tree_.lower_bound(value); }
# 773 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator lower_bound(const KeyType& key, KeyValueCompare comp)
   { return tree_.lower_bound(key, comp); }







   const_iterator lower_bound(const_reference value) const
   { return tree_.lower_bound(value); }
# 801 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const
   { return tree_.lower_bound(key, comp); }







   iterator upper_bound(const_reference value)
   { return tree_.upper_bound(value); }
# 829 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator upper_bound(const KeyType& key, KeyValueCompare comp)
   { return tree_.upper_bound(key, comp); }







   const_iterator upper_bound(const_reference value) const
   { return tree_.upper_bound(value); }
# 857 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
   { return tree_.upper_bound(key, comp); }







   iterator find(const_reference value)
   { return tree_.find(value); }
# 885 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator find(const KeyType& key, KeyValueCompare comp)
   { return tree_.find(key, comp); }







   const_iterator find(const_reference value) const
   { return tree_.find(value); }
# 913 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator find(const KeyType& key, KeyValueCompare comp) const
   { return tree_.find(key, comp); }
# 924 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<iterator,iterator> equal_range(const_reference value)
   { return tree_.equal_range(value); }
# 943 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
   { return tree_.equal_range(key, comp); }
# 954 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<const_iterator, const_iterator>
      equal_range(const_reference value) const
   { return tree_.equal_range(value); }
# 974 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType& key, KeyValueCompare comp) const
   { return tree_.equal_range(key, comp); }
# 994 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<iterator,iterator> bounded_range
      (const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed)
   { return tree_.bounded_range(lower_value, upper_value, left_closed, right_closed); }
# 1016 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> bounded_range
      (const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed)
   { return tree_.bounded_range(lower_key, upper_key, comp, left_closed, right_closed); }
# 1036 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<const_iterator, const_iterator>
      bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const
   { return tree_.bounded_range(lower_value, upper_value, left_closed, right_closed); }
# 1058 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator, const_iterator>
      bounded_range
         (const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const
   { return tree_.bounded_range(lower_key, upper_key, comp, left_closed, right_closed); }
# 1076 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static iterator s_iterator_to(reference value)
   { return tree_type::s_iterator_to(value); }
# 1091 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static const_iterator s_iterator_to(const_reference value)
   { return tree_type::s_iterator_to(value); }
# 1103 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator iterator_to(reference value)
   { return tree_.iterator_to(value); }
# 1115 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   const_iterator iterator_to(const_reference value) const
   { return tree_.iterator_to(value); }
# 1129 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static void init_node(reference value)
   { tree_type::init_node(value); }
# 1142 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   pointer unlink_leftmost_without_rebalance()
   { return tree_.unlink_leftmost_without_rebalance(); }
# 1159 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void replace_node(iterator replace_this, reference with_this)
   { tree_.replace_node(replace_this, with_this); }


   friend bool operator==(const set_impl &x, const set_impl &y)
   { return x.tree_ == y.tree_; }

   friend bool operator<(const set_impl &x, const set_impl &y)
   { return x.tree_ < y.tree_; }

};




template<class Config>

inline bool operator!=



(const set_impl<Config> &x, const set_impl<Config> &y)

{ return !(x == y); }




template<class Config>

inline bool operator>



(const set_impl<Config> &x, const set_impl<Config> &y)

{ return y < x; }




template<class Config>

inline bool operator<=



(const set_impl<Config> &x, const set_impl<Config> &y)

{ return !(y < x); }




template<class Config>

inline bool operator>=



(const set_impl<Config> &x, const set_impl<Config> &y)

{ return !(x < y); }




template<class Config>

inline void swap



(set_impl<Config> &x, set_impl<Config> &y)

{ x.swap(y); }






template<class T, class O1 = none, class O2 = none
                , class O3 = none, class O4 = none>

struct make_set
{

   typedef set_impl
      < typename make_rbtree_opt<T,

      O1, O2, O3, O4



      >::type
      > implementation_defined;

   typedef implementation_defined type;
};



template<class T, class O1, class O2, class O3, class O4>



class set
   : public make_set<T,

   O1, O2, O3, O4



   >::type
{
   typedef typename make_set
      <T,

      O1, O2, O3, O4



      >::type Base;

   private: set(set &); set& operator=(set &); public: operator ::boost::rv<set>&() { return *static_cast< ::boost::rv<set>* >(this); } operator const ::boost::rv<set>&() const { return *static_cast<const ::boost::rv<set>* >(this); } private:
   public:
   typedef typename Base::value_compare value_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((detail::is_same<typename value_traits::value_type, T>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_1292;

   set( const value_compare &cmp = value_compare()
         , const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   set( Iterator b, Iterator e
      , const value_compare &cmp = value_compare()
      , const value_traits &v_traits = value_traits())
      : Base(b, e, cmp, v_traits)
   {}

   set(::boost::rv< set >& x)
      : Base(::boost::move(static_cast<Base&>(x)))
   {}

   set& operator=(::boost::rv< set >& x)
   { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }

   static set &container_from_end_iterator(iterator end_iterator)
   { return static_cast<set &>(Base::container_from_end_iterator(end_iterator)); }

   static const set &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const set &>(Base::container_from_end_iterator(end_iterator)); }

   static set &container_from_iterator(iterator it)
   { return static_cast<set &>(Base::container_from_iterator(it)); }

   static const set &container_from_iterator(const_iterator it)
   { return static_cast<const set &>(Base::container_from_iterator(it)); }
};
# 1342 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
template<class Config>

class multiset_impl
{

   typedef rbtree_impl<Config> tree_type;

   private: multiset_impl(multiset_impl &); multiset_impl& operator=(multiset_impl &); public: operator ::boost::rv<multiset_impl>&() { return *static_cast< ::boost::rv<multiset_impl>* >(this); } operator const ::boost::rv<multiset_impl>&() const { return *static_cast<const ::boost::rv<multiset_impl>* >(this); } private:
   typedef tree_type implementation_defined;


   public:
   typedef typename implementation_defined::value_type value_type;
   typedef typename implementation_defined::value_traits value_traits;
   typedef typename implementation_defined::pointer pointer;
   typedef typename implementation_defined::const_pointer const_pointer;
   typedef typename implementation_defined::reference reference;
   typedef typename implementation_defined::const_reference const_reference;
   typedef typename implementation_defined::difference_type difference_type;
   typedef typename implementation_defined::size_type size_type;
   typedef typename implementation_defined::value_compare value_compare;
   typedef typename implementation_defined::key_compare key_compare;
   typedef typename implementation_defined::iterator iterator;
   typedef typename implementation_defined::const_iterator const_iterator;
   typedef typename implementation_defined::reverse_iterator reverse_iterator;
   typedef typename implementation_defined::const_reverse_iterator const_reverse_iterator;
   typedef typename implementation_defined::insert_commit_data insert_commit_data;
   typedef typename implementation_defined::node_traits node_traits;
   typedef typename implementation_defined::node node;
   typedef typename implementation_defined::node_ptr node_ptr;
   typedef typename implementation_defined::const_node_ptr const_node_ptr;
   typedef typename implementation_defined::node_algorithms node_algorithms;

   static const bool constant_time_size = Config::constant_time_size;



   private:
   tree_type tree_;

   protected:
   node &prot_header_node(){ return tree_.prot_header_node(); }
   node const &prot_header_node() const{ return tree_.prot_header_node(); }
   void prot_set_size(size_type s){ tree_.prot_set_size(s); }
   value_compare &prot_comp(){ return tree_.prot_comp(); }


   public:







   multiset_impl( const value_compare &cmp = value_compare()
                , const value_traits &v_traits = value_traits())
      : tree_(cmp, v_traits)
   {}
# 1414 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Iterator>
   multiset_impl( Iterator b, Iterator e
                , const value_compare &cmp = value_compare()
                , const value_traits &v_traits = value_traits())
      : tree_(false, b, e, cmp, v_traits)
   {}



   multiset_impl(::boost::rv< multiset_impl >& x)
      : tree_(::boost::move(x.tree_))
   {}



   multiset_impl& operator=(::boost::rv< multiset_impl >& x)
   { tree_ = ::boost::move(x.tree_); return *this; }
# 1439 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   ~multiset_impl()
   {}






   iterator begin()
   { return tree_.begin(); }






   const_iterator begin() const
   { return tree_.begin(); }






   const_iterator cbegin() const
   { return tree_.cbegin(); }






   iterator end()
   { return tree_.end(); }






   const_iterator end() const
   { return tree_.end(); }






   const_iterator cend() const
   { return tree_.cend(); }







   reverse_iterator rbegin()
   { return tree_.rbegin(); }







   const_reverse_iterator rbegin() const
   { return tree_.rbegin(); }







   const_reverse_iterator crbegin() const
   { return tree_.crbegin(); }







   reverse_iterator rend()
   { return tree_.rend(); }







   const_reverse_iterator rend() const
   { return tree_.rend(); }







   const_reverse_iterator crend() const
   { return tree_.crend(); }
# 1552 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static multiset_impl &container_from_end_iterator(iterator end_iterator)
   {
      return *detail::parent_from_member<multiset_impl, tree_type>
         ( &tree_type::container_from_end_iterator(end_iterator)
         , &multiset_impl::tree_);
   }
# 1567 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static const multiset_impl &container_from_end_iterator(const_iterator end_iterator)
   {
      return *detail::parent_from_member<multiset_impl, tree_type>
         ( &tree_type::container_from_end_iterator(end_iterator)
         , &multiset_impl::tree_);
   }
# 1581 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static multiset_impl &container_from_iterator(iterator it)
   {
      return *detail::parent_from_member<multiset_impl, tree_type>
         ( &tree_type::container_from_iterator(it)
         , &multiset_impl::tree_);
   }
# 1595 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static const multiset_impl &container_from_iterator(const_iterator it)
   {
      return *detail::parent_from_member<multiset_impl, tree_type>
         ( &tree_type::container_from_iterator(it)
         , &multiset_impl::tree_);
   }






   key_compare key_comp() const
   { return tree_.value_comp(); }






   value_compare value_comp() const
   { return tree_.value_comp(); }






   bool empty() const
   { return tree_.empty(); }







   size_type size() const
   { return tree_.size(); }







   void swap(multiset_impl& other)
   { tree_.swap(other.tree_); }
# 1658 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template <class Cloner, class Disposer>
   void clone_from(const multiset_impl &src, Cloner cloner, Disposer disposer)
   { tree_.clone_from(src.tree_, cloner, disposer); }
# 1676 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator insert(reference value)
   { return tree_.insert_equal(value); }
# 1694 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator insert(const_iterator hint, reference value)
   { return tree_.insert_equal(hint, value); }
# 1713 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Iterator>
   void insert(Iterator b, Iterator e)
   { tree_.insert_equal(b, e); }
# 1731 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator insert_before(const_iterator pos, reference value)
   { return tree_.insert_before(pos, value); }
# 1748 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void push_back(reference value)
   { tree_.push_back(value); }
# 1765 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void push_front(reference value)
   { tree_.push_front(value); }
# 1778 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator erase(const_iterator i)
   { return tree_.erase(i); }
# 1792 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator erase(const_iterator b, iterator e)
   { return tree_.erase(b, e); }
# 1805 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   size_type erase(const_reference value)
   { return tree_.erase(value); }
# 1819 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   size_type erase(const KeyType& key, KeyValueCompare comp

                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0

                  )
   { return tree_.erase(key, comp); }
# 1840 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer)
   { return tree_.erase_and_dispose(i, disposer); }


   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer)
   { return this->erase_and_dispose(const_iterator(i), disposer); }
# 1864 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer)
   { return tree_.erase_and_dispose(b, e, disposer); }
# 1881 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   size_type erase_and_dispose(const_reference value, Disposer disposer)
   { return tree_.erase_and_dispose(value, disposer); }
# 1899 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare, class Disposer>
   size_type erase_and_dispose(const KeyType& key, KeyValueCompare comp, Disposer disposer

                  , typename detail::enable_if_c<!detail::is_convertible<KeyValueCompare, const_iterator>::value >::type * = 0

                  )
   { return tree_.erase_and_dispose(key, comp, disposer); }
# 1916 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void clear()
   { return tree_.clear(); }
# 1930 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class Disposer>
   void clear_and_dispose(Disposer disposer)
   { return tree_.clear_and_dispose(disposer); }







   size_type count(const_reference value) const
   { return tree_.count(value); }
# 1950 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   size_type count(const KeyType& key, KeyValueCompare comp) const
   { return tree_.count(key, comp); }







   iterator lower_bound(const_reference value)
   { return tree_.lower_bound(value); }
# 1978 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator lower_bound(const KeyType& key, KeyValueCompare comp)
   { return tree_.lower_bound(key, comp); }







   const_iterator lower_bound(const_reference value) const
   { return tree_.lower_bound(value); }
# 2006 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator lower_bound(const KeyType& key, KeyValueCompare comp) const
   { return tree_.lower_bound(key, comp); }







   iterator upper_bound(const_reference value)
   { return tree_.upper_bound(value); }
# 2034 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator upper_bound(const KeyType& key, KeyValueCompare comp)
   { return tree_.upper_bound(key, comp); }







   const_iterator upper_bound(const_reference value) const
   { return tree_.upper_bound(value); }
# 2062 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator upper_bound(const KeyType& key, KeyValueCompare comp) const
   { return tree_.upper_bound(key, comp); }







   iterator find(const_reference value)
   { return tree_.find(value); }
# 2090 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   iterator find(const KeyType& key, KeyValueCompare comp)
   { return tree_.find(key, comp); }







   const_iterator find(const_reference value) const
   { return tree_.find(value); }
# 2118 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   const_iterator find(const KeyType& key, KeyValueCompare comp) const
   { return tree_.find(key, comp); }
# 2129 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<iterator,iterator> equal_range(const_reference value)
   { return tree_.equal_range(value); }
# 2148 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> equal_range(const KeyType& key, KeyValueCompare comp)
   { return tree_.equal_range(key, comp); }
# 2159 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<const_iterator, const_iterator>
      equal_range(const_reference value) const
   { return tree_.equal_range(value); }
# 2179 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator, const_iterator>
      equal_range(const KeyType& key, KeyValueCompare comp) const
   { return tree_.equal_range(key, comp); }
# 2199 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<iterator,iterator> bounded_range
      (const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed)
   { return tree_.bounded_range(lower_value, upper_value, left_closed, right_closed); }
# 2221 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<iterator,iterator> bounded_range
      (const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed)
   { return tree_.bounded_range(lower_key, upper_key, comp, left_closed, right_closed); }
# 2241 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   std::pair<const_iterator, const_iterator>
      bounded_range(const_reference lower_value, const_reference upper_value, bool left_closed, bool right_closed) const
   { return tree_.bounded_range(lower_value, upper_value, left_closed, right_closed); }
# 2263 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   template<class KeyType, class KeyValueCompare>
   std::pair<const_iterator, const_iterator>
      bounded_range
         (const KeyType& lower_key, const KeyType& upper_key, KeyValueCompare comp, bool left_closed, bool right_closed) const
   { return tree_.bounded_range(lower_key, upper_key, comp, left_closed, right_closed); }
# 2281 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static iterator s_iterator_to(reference value)
   { return tree_type::s_iterator_to(value); }
# 2296 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static const_iterator s_iterator_to(const_reference value)
   { return tree_type::s_iterator_to(value); }
# 2308 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   iterator iterator_to(reference value)
   { return tree_.iterator_to(value); }
# 2320 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   const_iterator iterator_to(const_reference value) const
   { return tree_.iterator_to(value); }
# 2334 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static void init_node(reference value)
   { tree_type::init_node(value); }
# 2347 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   pointer unlink_leftmost_without_rebalance()
   { return tree_.unlink_leftmost_without_rebalance(); }
# 2364 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   void replace_node(iterator replace_this, reference with_this)
   { tree_.replace_node(replace_this, with_this); }
# 2379 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp"
   static void remove_node(reference value)
   { tree_type::remove_node(value); }


   friend bool operator==(const multiset_impl &x, const multiset_impl &y)
   { return x.tree_ == y.tree_; }

   friend bool operator<(const multiset_impl &x, const multiset_impl &y)
   { return x.tree_ < y.tree_; }

};




template<class Config>

inline bool operator!=



(const multiset_impl<Config> &x, const multiset_impl<Config> &y)

{ return !(x == y); }




template<class Config>

inline bool operator>



(const multiset_impl<Config> &x, const multiset_impl<Config> &y)

{ return y < x; }




template<class Config>

inline bool operator<=



(const multiset_impl<Config> &x, const multiset_impl<Config> &y)

{ return !(y < x); }




template<class Config>

inline bool operator>=



(const multiset_impl<Config> &x, const multiset_impl<Config> &y)

{ return !(x < y); }




template<class Config>

inline void swap



(multiset_impl<Config> &x, multiset_impl<Config> &y)

{ x.swap(y); }






template<class T, class O1 = none, class O2 = none
                , class O3 = none, class O4 = none>

struct make_multiset
{

   typedef multiset_impl
      < typename make_rbtree_opt<T,

      O1, O2, O3, O4



      >::type
      > implementation_defined;

   typedef implementation_defined type;
};




template<class T, class O1, class O2, class O3, class O4>



class multiset
   : public make_multiset<T,

      O1, O2, O3, O4



      >::type
{
   typedef typename make_multiset<T,

      O1, O2, O3, O4



      >::type Base;

   private: multiset(multiset &); multiset& operator=(multiset &); public: operator ::boost::rv<multiset>&() { return *static_cast< ::boost::rv<multiset>* >(this); } operator const ::boost::rv<multiset>&() const { return *static_cast<const ::boost::rv<multiset>* >(this); } private:

   public:
   typedef typename Base::value_compare value_compare;
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((detail::is_same<typename value_traits::value_type, T>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_2513;

   multiset( const value_compare &cmp = value_compare()
           , const value_traits &v_traits = value_traits())
      : Base(cmp, v_traits)
   {}

   template<class Iterator>
   multiset( Iterator b, Iterator e
           , const value_compare &cmp = value_compare()
           , const value_traits &v_traits = value_traits())
      : Base(b, e, cmp, v_traits)
   {}

   multiset(::boost::rv< multiset >& x)
      : Base(::boost::move(static_cast<Base&>(x)))
   {}

   multiset& operator=(::boost::rv< multiset >& x)
   { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }

   static multiset &container_from_end_iterator(iterator end_iterator)
   { return static_cast<multiset &>(Base::container_from_end_iterator(end_iterator)); }

   static const multiset &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const multiset &>(Base::container_from_end_iterator(end_iterator)); }

   static multiset &container_from_iterator(iterator it)
   { return static_cast<multiset &>(Base::container_from_iterator(it)); }

   static const multiset &container_from_iterator(const_iterator it)
   { return static_cast<const multiset &>(Base::container_from_iterator(it)); }
};



}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 2553 "/opt/sevenflow/boost/include/boost/intrusive/set.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/interprocess/indexes/iset_index.hpp" 2






namespace boost {
namespace interprocess {




template <class MapConfig>
struct iset_index_aux
{
   typedef typename
      MapConfig::segment_manager_base segment_manager_base;

   typedef typename
      segment_manager_base::void_pointer void_pointer;
   typedef typename bi::make_set_base_hook
      < bi::void_pointer<void_pointer>
      , bi::optimize_size<true>
      >::type derivation_hook;

   typedef typename MapConfig::template
      intrusive_value_type<derivation_hook>::type value_type;
   typedef std::less<value_type> value_compare;
   typedef typename bi::make_set
      < value_type
      , bi::base_hook<derivation_hook>
      >::type index_t;
};





template <class MapConfig>
class iset_index

   : public iset_index_aux<MapConfig>::index_t
{

   typedef iset_index_aux<MapConfig> index_aux;
   typedef typename index_aux::index_t index_type;
   typedef typename MapConfig::
      intrusive_compare_key_type intrusive_compare_key_type;
   typedef typename MapConfig::char_type char_type;


   public:
   typedef typename index_type::iterator iterator;
   typedef typename index_type::const_iterator const_iterator;
   typedef typename index_type::insert_commit_data insert_commit_data;
   typedef typename index_type::value_type value_type;


   private:

   struct intrusive_key_value_less
   {
      bool operator()(const intrusive_compare_key_type &i, const value_type &b) const
      {
         std::size_t blen = b.name_length();
         return (i.m_len < blen) ||
                  (i.m_len == blen &&
                  std::char_traits<char_type>::compare
                     (i.mp_str, b.name(), i.m_len) < 0);
      }

      bool operator()(const value_type &b, const intrusive_compare_key_type &i) const
      {
         std::size_t blen = b.name_length();
         return (blen < i.m_len) ||
                  (blen == i.m_len &&
                  std::char_traits<char_type>::compare
                     (b.name(), i.mp_str, i.m_len) < 0);
      }
   };



   public:



   iset_index(typename MapConfig::segment_manager_base *)
      : index_type( )
   {}



   void reserve(typename MapConfig::segment_manager_base::size_type)
   { }


   void shrink_to_fit()
   { }

   iterator find(const intrusive_compare_key_type &key)
   { return index_type::find(key, intrusive_key_value_less()); }

   const_iterator find(const intrusive_compare_key_type &key) const
   { return index_type::find(key, intrusive_key_value_less()); }

   std::pair<iterator, bool>insert_check
      (const intrusive_compare_key_type &key, insert_commit_data &commit_data)
   { return index_type::insert_check(key, intrusive_key_value_less(), commit_data); }
};





template<class MapConfig>
struct is_intrusive_index
   <boost::interprocess::iset_index<MapConfig> >
{
   static const bool value = true;
};


}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 149 "/opt/sevenflow/boost/include/boost/interprocess/indexes/iset_index.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/interprocess/containers/allocation_type.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/containers/allocation_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/containers/allocation_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/detail/allocation_type.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/container/detail/allocation_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/container/detail/allocation_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/detail/workaround.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/container/detail/workaround.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/container/detail/workaround.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/container/detail/workaround.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 35 "/opt/sevenflow/boost/include/boost/container/detail/workaround.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/container/detail/allocation_type.hpp" 2

namespace boost {
namespace container {


enum allocation_type_v
{

   allocate_new_v = 0x01,
   expand_fwd_v = 0x02,
   expand_bwd_v = 0x04,


   shrink_in_place_v = 0x08,
   nothrow_allocation_v = 0x10,
   zero_memory_v = 0x20,
   try_shrink_in_place_v = 0x40
};

typedef int allocation_type;

static const allocation_type allocate_new = (allocation_type)allocate_new_v;
static const allocation_type expand_fwd = (allocation_type)expand_fwd_v;
static const allocation_type expand_bwd = (allocation_type)expand_bwd_v;
static const allocation_type shrink_in_place = (allocation_type)shrink_in_place_v;
static const allocation_type try_shrink_in_place= (allocation_type)try_shrink_in_place_v;
static const allocation_type nothrow_allocation = (allocation_type)nothrow_allocation_v;
static const allocation_type zero_memory = (allocation_type)zero_memory_v;

}
}

# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 53 "/opt/sevenflow/boost/include/boost/container/detail/allocation_type.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/interprocess/containers/allocation_type.hpp" 2

namespace boost {
namespace interprocess {


typedef int allocation_type;

static const allocation_type allocate_new = boost::container::allocate_new;
static const allocation_type expand_fwd = boost::container::expand_fwd;
static const allocation_type expand_bwd = boost::container::expand_bwd;
static const allocation_type shrink_in_place = boost::container::shrink_in_place;
static const allocation_type try_shrink_in_place= boost::container::try_shrink_in_place;
static const allocation_type nothrow_allocation = boost::container::nothrow_allocation;
static const allocation_type zero_memory = boost::container::zero_memory;

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 39 "/opt/sevenflow/boost/include/boost/interprocess/containers/allocation_type.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/container_fwd.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/container/container_fwd.hpp"
namespace boost{
namespace intrusive{

}}

namespace boost{ namespace container{ namespace container_detail{

namespace bi = boost::intrusive;

}}}
# 47 "/opt/sevenflow/boost/include/boost/container/container_fwd.hpp"
namespace boost {
namespace container {


template <class T
         ,class A = std::allocator<T> >
class vector;


template <class T
         ,class A = std::allocator<T> >
class stable_vector;


template <class T
         ,class A = std::allocator<T> >
class deque;


template <class T
         ,class A = std::allocator<T> >
class list;


template <class T
         ,class A = std::allocator<T> >
class slist;


template <class T
         ,class Pred = std::less<T>
         ,class A = std::allocator<T> >
class set;


template <class T
         ,class Pred = std::less<T>
         ,class A = std::allocator<T> >
class multiset;


template <class Key
         ,class T
         ,class Pred = std::less<Key>
         ,class A = std::allocator<std::pair<const Key, T> > >
class map;


template <class Key
         ,class T
         ,class Pred = std::less<Key>
         ,class A = std::allocator<std::pair<const Key, T> > >
class multimap;


template <class T
         ,class Pred = std::less<T>
         ,class A = std::allocator<T> >
class flat_set;


template <class T
         ,class Pred = std::less<T>
         ,class A = std::allocator<T> >
class flat_multiset;


template <class Key
         ,class T
         ,class Pred = std::less<Key>
         ,class A = std::allocator<std::pair<Key, T> > >
class flat_map;


template <class Key
         ,class T
         ,class Pred = std::less<Key>
         ,class A = std::allocator<std::pair<Key, T> > >
class flat_multimap;


template <class CharT
         ,class Traits = std::char_traits<CharT>
         ,class A = 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;
   }
};

}



}}
# 16 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstdio" 1 3
# 39 "/usr/include/c++/4.8.2/cstdio" 3
       
# 40 "/usr/include/c++/4.8.2/cstdio" 3
# 16 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_fundamental.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/is_fundamental.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/is_fundamental.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 44 "/opt/sevenflow/boost/include/boost/type_traits/is_fundamental.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_class.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/type_traits/is_class.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 38 "/opt/sevenflow/boost/include/boost/type_traits/is_class.hpp" 2

namespace boost {

namespace detail {
# 120 "/opt/sevenflow/boost/include/boost/type_traits/is_class.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 139 "/opt/sevenflow/boost/include/boost/type_traits/is_class.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/container/detail/preprocessor.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/container/detail/preprocessor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/container/detail/preprocessor.hpp" 2
# 177 "/opt/sevenflow/boost/include/boost/container/detail/preprocessor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 178 "/opt/sevenflow/boost/include/boost/container/detail/preprocessor.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace container { namespace container_detail {

      template <typename Type>
      class has_member_function_named_allocate
      {
         struct BaseMixin
         {
            void allocate();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::allocate>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void , class P1 = void>
         struct has_member_function_callable_with_allocate_impl;


         template<typename Fun , class P0 , class P1>
         struct has_member_function_callable_with_allocate_impl
            <Fun, false , P0 , P1>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           allocate (), 0))>
            struct zeroarg_checker_allocate
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_allocate(int);
            };



            template<class F>
            struct zeroarg_checker_allocate<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_allocate(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_allocate_impl
               <Fun, true , void , void>
            {
               template<class U>
               static zeroarg_checker_allocate<U>
                  Test(zeroarg_checker_allocate<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap1_allocate

            : Fun
         {
            funwrap1_allocate
                                                                                                      ();

            using Fun::allocate;
            boost_intrusive_has_member_function_callable_with::private_type
               allocate
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_allocate_impl

            <Fun, true
            , P0
            , void

                                         >
         {
            typedef funwrap1_allocate
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              allocate
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap2_allocate

            : Fun
         {
            funwrap2_allocate
                                                                                                      ();

            using Fun::allocate;
            boost_intrusive_has_member_function_callable_with::private_type
               allocate
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1>
         struct has_member_function_callable_with_allocate_impl

            <Fun, true
            , P0 , P1
           

                                         >
         {
            typedef funwrap2_allocate
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              allocate
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun
                  , class P0 = void , class P1 = void>
         struct has_member_function_callable_with_allocate
            : public has_member_function_callable_with_allocate_impl
               <Fun, has_member_function_named_allocate<Fun>::value
               , P0 , P1 >
         {};

         }}}
# 58 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace container { namespace container_detail {

      template <typename Type>
      class has_member_function_named_destroy
      {
         struct BaseMixin
         {
            void destroy();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::destroy>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void , class P1 = void , class P2 = void>
         struct has_member_function_callable_with_destroy_impl;


         template<typename Fun , class P0 , class P1 , class P2>
         struct has_member_function_callable_with_destroy_impl
            <Fun, false , P0 , P1 , P2>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           destroy (), 0))>
            struct zeroarg_checker_destroy
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_destroy(int);
            };



            template<class F>
            struct zeroarg_checker_destroy<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_destroy(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_destroy_impl
               <Fun, true , void , void , void>
            {
               template<class U>
               static zeroarg_checker_destroy<U>
                  Test(zeroarg_checker_destroy<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap1_destroy

            : Fun
         {
            funwrap1_destroy
                                                                                                      ();

            using Fun::destroy;
            boost_intrusive_has_member_function_callable_with::private_type
               destroy
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_destroy_impl

            <Fun, true
            , P0
            , void , void

                                         >
         {
            typedef funwrap1_destroy
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              destroy
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap2_destroy

            : Fun
         {
            funwrap2_destroy
                                                                                                      ();

            using Fun::destroy;
            boost_intrusive_has_member_function_callable_with::private_type
               destroy
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1>
         struct has_member_function_callable_with_destroy_impl

            <Fun, true
            , P0 , P1
            , void

                                         >
         {
            typedef funwrap2_destroy
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              destroy
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 58 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap3_destroy

            : Fun
         {
            funwrap3_destroy
                                                                                                      ();

            using Fun::destroy;
            boost_intrusive_has_member_function_callable_with::private_type
               destroy
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2>
         struct has_member_function_callable_with_destroy_impl

            <Fun, true
            , P0 , P1 , P2
           

                                         >
         {
            typedef funwrap3_destroy
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              destroy
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun
                  , class P0 = void , class P1 = void , class P2 = void>
         struct has_member_function_callable_with_destroy
            : public has_member_function_callable_with_destroy_impl
               <Fun, has_member_function_named_destroy<Fun>::value
               , P0 , P1 , P2 >
         {};

         }}}
# 63 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace container { namespace container_detail {

      template <typename Type>
      class has_member_function_named_max_size
      {
         struct BaseMixin
         {
            void max_size();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::max_size>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  >
         struct has_member_function_callable_with_max_size_impl;


         template<typename Fun >
         struct has_member_function_callable_with_max_size_impl
            <Fun, false >
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           max_size (), 0))>
            struct zeroarg_checker_max_size
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_max_size(int);
            };



            template<class F>
            struct zeroarg_checker_max_size<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_max_size(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_max_size_impl
               <Fun, true >
            {
               template<class U>
               static zeroarg_checker_max_size<U>
                  Test(zeroarg_checker_max_size<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun
                  >
         struct has_member_function_callable_with_max_size
            : public has_member_function_callable_with_max_size_impl
               <Fun, has_member_function_named_max_size<Fun>::value
               >
         {};

         }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace container { namespace container_detail {

      template <typename Type>
      class has_member_function_named_select_on_container_copy_construction
      {
         struct BaseMixin
         {
            void select_on_container_copy_construction();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::select_on_container_copy_construction>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  >
         struct has_member_function_callable_with_select_on_container_copy_construction_impl;


         template<typename Fun >
         struct has_member_function_callable_with_select_on_container_copy_construction_impl
            <Fun, false >
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           select_on_container_copy_construction (), 0))>
            struct zeroarg_checker_select_on_container_copy_construction
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_select_on_container_copy_construction(int);
            };



            template<class F>
            struct zeroarg_checker_select_on_container_copy_construction<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_select_on_container_copy_construction(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_select_on_container_copy_construction_impl
               <Fun, true >
            {
               template<class U>
               static zeroarg_checker_select_on_container_copy_construction<U>
                  Test(zeroarg_checker_select_on_container_copy_construction<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun
                  >
         struct has_member_function_callable_with_select_on_container_copy_construction
            : public has_member_function_callable_with_select_on_container_copy_construction_impl
               <Fun, has_member_function_named_select_on_container_copy_construction<Fun>::value
               >
         {};

         }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/slot/detail/shared.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 78 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      namespace boost { namespace container { namespace container_detail {

      template <typename Type>
      class has_member_function_named_construct
      {
         struct BaseMixin
         {
            void construct();
         };

         struct Base : public Type, public BaseMixin { Base(); };
         template <typename T, T t> class Helper{};

         template <typename U>
         static boost_intrusive_has_member_function_callable_with::no_type deduce
            (U*, Helper<void (BaseMixin::*)(), &U::construct>* = 0);
         static boost_intrusive_has_member_function_callable_with::yes_type deduce(...);

         public:
         static const bool value =
            sizeof(boost_intrusive_has_member_function_callable_with::yes_type) == sizeof(deduce((Base*)(0)));
      };



         template<typename Fun, bool HasFunc
                  , class P0 = void , class P1 = void , class P2 = void , class P3 = void , class P4 = void , class P5 = void , class P6 = void , class P7 = void , class P8 = void , class P9 = void , class P10 = void>
         struct has_member_function_callable_with_construct_impl;


         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10>
         struct has_member_function_callable_with_construct_impl
            <Fun, false , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10>
         {
            static const bool value = false;
         };
# 132 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
            template< class F
                  , std::size_t N =
                        sizeof((boost::move_detail::declval<F>().
                           construct (), 0))>
            struct zeroarg_checker_construct
            {
               boost_intrusive_has_member_function_callable_with::yes_type dummy;
               zeroarg_checker_construct(int);
            };



            template<class F>
            struct zeroarg_checker_construct<F, 0>
            {
               boost_intrusive_has_member_function_callable_with::no_type dummy;
               zeroarg_checker_construct(int);
            };

            template<typename Fun>
            struct has_member_function_callable_with_construct_impl
               <Fun, true , void , void , void , void , void , void , void , void , void , void , void>
            {
               template<class U>
               static zeroarg_checker_construct<U>
                  Test(zeroarg_checker_construct<U>*);

               template <class U>
               static boost_intrusive_has_member_function_callable_with::no_type Test(...);

               static const bool value = sizeof(Test< Fun >(0))
                                    == sizeof(boost_intrusive_has_member_function_callable_with::yes_type);
            };
# 279 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
      }}}
# 48 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap1_construct

            : Fun
         {
            funwrap1_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0
            , void , void , void , void , void , void , void , void , void , void

                                         >
         {
            typedef funwrap1_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 53 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap2_construct

            : Fun
         {
            funwrap2_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1
            , void , void , void , void , void , void , void , void , void

                                         >
         {
            typedef funwrap2_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 58 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap3_construct

            : Fun
         {
            funwrap3_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2
            , void , void , void , void , void , void , void , void

                                         >
         {
            typedef funwrap3_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 63 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap4_construct

            : Fun
         {
            funwrap4_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3
            , void , void , void , void , void , void , void

                                         >
         {
            typedef funwrap4_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 68 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap5_construct

            : Fun
         {
            funwrap5_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4
            , void , void , void , void , void , void

                                         >
         {
            typedef funwrap5_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 73 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap6_construct

            : Fun
         {
            funwrap6_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4 , P5
            , void , void , void , void , void

                                         >
         {
            typedef funwrap6_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() , boost::move_detail::declval< P5 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 78 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap7_construct

            : Fun
         {
            funwrap7_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4 , P5 , P6
            , void , void , void , void

                                         >
         {
            typedef funwrap7_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() , boost::move_detail::declval< P5 >() , boost::move_detail::declval< P6 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 83 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap8_construct

            : Fun
         {
            funwrap8_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7
            , void , void , void

                                         >
         {
            typedef funwrap8_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() , boost::move_detail::declval< P5 >() , boost::move_detail::declval< P6 >() , boost::move_detail::declval< P7 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 88 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap9_construct

            : Fun
         {
            funwrap9_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
            , void , void

                                         >
         {
            typedef funwrap9_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() , boost::move_detail::declval< P5 >() , boost::move_detail::declval< P6 >() , boost::move_detail::declval< P7 >() , boost::move_detail::declval< P8 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 93 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap10_construct

            : Fun
         {
            funwrap10_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9
            , void

                                         >
         {
            typedef funwrap10_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() , boost::move_detail::declval< P5 >() , boost::move_detail::declval< P6 >() , boost::move_detail::declval< P7 >() , boost::move_detail::declval< P8 >() , boost::move_detail::declval< P9 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 98 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1
# 285 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun>
         struct funwrap11_construct

            : Fun
         {
            funwrap11_construct
                                                                                                      ();

            using Fun::construct;
            boost_intrusive_has_member_function_callable_with::private_type
               construct
                  ( boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care , boost_intrusive_has_member_function_callable_with::dont_care

                                                                                 ) const;
         };

         template<typename Fun , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 , class P10>
         struct has_member_function_callable_with_construct_impl

            <Fun, true
            , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10
           

                                         >
         {
            typedef funwrap11_construct
                                                                                                            <Fun>
                     FunWrap;
            static bool const value =
            (sizeof(boost_intrusive_has_member_function_callable_with::no_type) ==
               sizeof(boost_intrusive_has_member_function_callable_with::is_private_type
                        ( (boost::move_detail::declval<FunWrap>().
                              construct
                                 ( boost::move_detail::declval< P0 >() , boost::move_detail::declval< P1 >() , boost::move_detail::declval< P2 >() , boost::move_detail::declval< P3 >() , boost::move_detail::declval< P4 >() , boost::move_detail::declval< P5 >() , boost::move_detail::declval< P6 >() , boost::move_detail::declval< P7 >() , boost::move_detail::declval< P8 >() , boost::move_detail::declval< P9 >() , boost::move_detail::declval< P10 >() ), 0
                           )
                        )
                     )
            );
         };

         }}}
# 336 "/opt/sevenflow/boost/include/boost/intrusive/detail/has_member_function_callable_with.hpp"
         namespace boost { namespace container { namespace container_detail {

         template<typename Fun
                  , class P0 = void , class P1 = void , class P2 = void , class P3 = void , class P4 = void , class P5 = void , class P6 = void , class P7 = void , class P8 = void , class P9 = void , class P10 = void>
         struct has_member_function_callable_with_construct
            : public has_member_function_callable_with_construct_impl
               <Fun, has_member_function_named_construct<Fun>::value
               , P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8 , P9 , P10 >
         {};

         }}}
# 103 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
# 53 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2

namespace boost {
namespace container {
namespace container_detail {


template <typename T, typename DefaultType> struct boost_intrusive_default_type_pointer { template <typename X> static char test(int, typename X::pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::pointer type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_pointer { template <typename X> static char test(int, typename X::pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::pointer type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_const_pointer { template <typename X> static char test(int, typename X::const_pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType const_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::const_pointer type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_const_pointer { template <typename X> static char test(int, typename X::const_pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type const_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::const_pointer type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_reference { template <typename X> static char test(int, typename X::reference*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType reference; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::reference type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_reference { template <typename X> static char test(int, typename X::reference*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type reference; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::reference type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_const_reference { template <typename X> static char test(int, typename X::const_reference*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType const_reference; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::const_reference type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_const_reference { template <typename X> static char test(int, typename X::const_reference*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type const_reference; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::const_reference type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_void_pointer { template <typename X> static char test(int, typename X::void_pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType void_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::void_pointer type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_void_pointer { template <typename X> static char test(int, typename X::void_pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type void_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::void_pointer type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_const_void_pointer { template <typename X> static char test(int, typename X::const_void_pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType const_void_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::const_void_pointer type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_const_void_pointer { template <typename X> static char test(int, typename X::const_void_pointer*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type const_void_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::const_void_pointer type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_size_type { template <typename X> static char test(int, typename X::size_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType size_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::size_type type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_size_type { template <typename X> static char test(int, typename X::size_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type size_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::size_type type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_propagate_on_container_copy_assignment { template <typename X> static char test(int, typename X::propagate_on_container_copy_assignment*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType propagate_on_container_copy_assignment; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::propagate_on_container_copy_assignment type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_propagate_on_container_copy_assignment { template <typename X> static char test(int, typename X::propagate_on_container_copy_assignment*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type propagate_on_container_copy_assignment; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::propagate_on_container_copy_assignment type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_propagate_on_container_move_assignment { template <typename X> static char test(int, typename X::propagate_on_container_move_assignment*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType propagate_on_container_move_assignment; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::propagate_on_container_move_assignment type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_propagate_on_container_move_assignment { template <typename X> static char test(int, typename X::propagate_on_container_move_assignment*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type propagate_on_container_move_assignment; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::propagate_on_container_move_assignment type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_propagate_on_container_swap { template <typename X> static char test(int, typename X::propagate_on_container_swap*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType propagate_on_container_swap; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::propagate_on_container_swap type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_propagate_on_container_swap { template <typename X> static char test(int, typename X::propagate_on_container_swap*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type propagate_on_container_swap; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::propagate_on_container_swap type; };
template <typename T, typename DefaultType> struct boost_intrusive_default_type_difference_type { template <typename X> static char test(int, typename X::difference_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef DefaultType difference_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::if_c <value, T, DefaultWrap>::type::difference_type type; }; template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_difference_type { template <typename X> static char test(int, typename X::difference_type*); template <typename X> static int test(boost::intrusive::detail:: LowPriorityConversion<int>, void*); struct DefaultWrap { typedef typename DefaultType::type difference_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::difference_type type; };

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 76 "/opt/sevenflow/boost/include/boost/container/detail/memory_util.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 2
# 39 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
namespace boost {
namespace container {
namespace container_detail {



template<class A>
struct is_std_allocator
{ static const bool value = false; };

template<class T>
struct is_std_allocator< std::allocator<T> >
{ static const bool value = true; };

}





template <typename Alloc>
struct allocator_traits
{

   typedef Alloc allocator_type;

   typedef typename Alloc::value_type value_type;
# 121 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
      typedef typename boost::container::container_detail:: boost_intrusive_default_type_pointer< Alloc, value_type* >::type

            pointer;

      typedef typename boost::container::container_detail:: boost_intrusive_eval_default_type_const_pointer< Alloc, typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<const value_type> >::type


               const_pointer;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_reference< Alloc, typename container_detail::unvoid<value_type>::type& >::type

            reference;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_const_reference< Alloc, const typename container_detail::unvoid<value_type>::type& >::type

               const_reference;

      typedef typename boost::container::container_detail:: boost_intrusive_eval_default_type_void_pointer< Alloc, typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<void> >::type


               void_pointer;

      typedef typename boost::container::container_detail:: boost_intrusive_eval_default_type_const_void_pointer< Alloc, typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<const void> >::type


               const_void_pointer;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_difference_type< Alloc, std::ptrdiff_t >::type

            difference_type;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_size_type< Alloc, std::size_t >::type

            size_type;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_propagate_on_container_copy_assignment< Alloc, boost::false_type >::type

            propagate_on_container_copy_assignment;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_propagate_on_container_move_assignment< Alloc, boost::false_type >::type

            propagate_on_container_move_assignment;

      typedef typename boost::container::container_detail:: boost_intrusive_default_type_propagate_on_container_swap< Alloc, boost::false_type >::type

            propagate_on_container_swap;







         template <typename T>
         struct rebind_alloc : boost::intrusive::detail::type_rebinder<Alloc,T>::type
         {
            typedef typename boost::intrusive::detail::type_rebinder<Alloc,T>::type Base;
# 191 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        rebind_alloc() : Base() {}


        template< class P0 > rebind_alloc( const P0 & p0) : Base( ::boost::forward< P0 >( p0 )) {}


        template< class P0 , class P1 > rebind_alloc( const P0 & p0 , const P1 & p1) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 )) {}


        template< class P0 , class P1 , class P2 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 )) {}


        template< class P0 , class P1 , class P2 , class P3 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 )) {}


        template< class P0 , class P1 , class P2 , class P3 , class P4 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 )) {}


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 )) {}


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 )) {}


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 )) {}


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 )) {}


        template< class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > rebind_alloc( const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9) : Base( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 )) {}
# 192 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 2

         };

         template <typename T>
         struct rebind_traits
            : allocator_traits<typename boost::intrusive::detail::type_rebinder<Alloc, T>::type>
         {};

      template <class T>
      struct portable_rebind_alloc
      { typedef typename boost::intrusive::detail::type_rebinder<Alloc, T>::type type; };




   static pointer allocate(Alloc &a, size_type n)
   { return a.allocate(n); }




   static void deallocate(Alloc &a, pointer p, size_type n)
   { return a.deallocate(p, n); }



   static pointer allocate(Alloc &a, size_type n, const_void_pointer p)
   {
      const bool value = boost::container::container_detail::
         has_member_function_callable_with_allocate
            <Alloc, const size_type, const const_void_pointer>::value;
      ::boost::integral_constant<bool, value> flag;
      return allocator_traits::priv_allocate(flag, a, n, p);
   }



   template<class T>
   static void destroy(Alloc &a, T*p)
   {
      typedef T* destroy_pointer;
      const bool value = boost::container::container_detail::
         has_member_function_callable_with_destroy
            <Alloc, const destroy_pointer>::value;
      ::boost::integral_constant<bool, value> flag;
      allocator_traits::priv_destroy(flag, a, p);
   }



   static size_type max_size(const Alloc &a)
   {
      const bool value = boost::container::container_detail::
         has_member_function_callable_with_max_size
            <const Alloc>::value;
      ::boost::integral_constant<bool, value> flag;
      return allocator_traits::priv_max_size(flag, a);
   }



   static Alloc select_on_container_copy_construction(const Alloc &a)
   {
      const bool value = boost::container::container_detail::
         has_member_function_callable_with_select_on_container_copy_construction
            <const Alloc>::value;
      ::boost::integral_constant<bool, value> flag;
      return allocator_traits::priv_select_on_container_copy_construction(flag, a);
   }
# 274 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
      private:
      static pointer priv_allocate(boost::true_type, Alloc &a, size_type n, const_void_pointer p)
      { return a.allocate(n, p); }

      static pointer priv_allocate(boost::false_type, Alloc &a, size_type n, const_void_pointer)
      { return allocator_traits::allocate(a, n); }

      template<class T>
      static void priv_destroy(boost::true_type, Alloc &a, T* p)
      { a.destroy(p); }

      template<class T>
      static void priv_destroy(boost::false_type, Alloc &, T* p)
      { p->~T(); (void)p; }

      static size_type priv_max_size(boost::true_type, const Alloc &a)
      { return a.max_size(); }

      static size_type priv_max_size(boost::false_type, const Alloc &)
      { return (std::numeric_limits<size_type>::max)(); }

      static Alloc priv_select_on_container_copy_construction(boost::true_type, const Alloc &a)
      { return a.select_on_container_copy_construction(); }

      static Alloc priv_select_on_container_copy_construction(boost::false_type, const Alloc &a)
      { return a; }
# 326 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
         public:
# 338 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        template<class T > static void construct(Alloc &a, T *p ) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p ); }


        template<class T , class P0 > static void construct(Alloc &a, T *p , const P0 & p0) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 )); }


        template<class T , class P0 , class P1 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 )); }


        template<class T , class P0 , class P1 , class P2 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > static void construct(Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9) { ::boost::integral_constant<bool, container_detail::is_std_allocator<Alloc>::value> flag; allocator_traits::priv_construct(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 )); }
# 339 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 2

         private:
# 373 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/preprocessor/iteration/detail/local.hpp"
        template<class T > static void priv_construct(boost::false_type, Alloc &a, T *p ) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p ); } template<class T > static void priv_construct(boost::true_type, Alloc &a, T *p ) { priv_construct_dispatch2(boost::false_type(), a, p ); } template<class T > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p ) { a.construct( p ); } template<class T > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p ) { ::new((void*)p) T(); }


        template<class T , class P0 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) ); } template<class T , class P0 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) ); } template<class T , class P0 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0) { a.construct( p , ::boost::forward< P0 >( p0 ) ); } template<class T , class P0 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 )); }


        template<class T , class P0 , class P1 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) ); } template<class T , class P0 , class P1 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) ); } template<class T , class P0 , class P1 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) ); } template<class T , class P0 , class P1 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 )); }


        template<class T , class P0 , class P1 , class P2 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) ); } template<class T , class P0 , class P1 , class P2 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) ); } template<class T , class P0 , class P1 , class P2 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) ); } template<class T , class P0 , class P1 , class P2 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type , typename ::boost::move_detail::forward_type< P4 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type , typename ::boost::move_detail::forward_type< P4 >::type , typename ::boost::move_detail::forward_type< P5 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type , typename ::boost::move_detail::forward_type< P4 >::type , typename ::boost::move_detail::forward_type< P5 >::type , typename ::boost::move_detail::forward_type< P6 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type , typename ::boost::move_detail::forward_type< P4 >::type , typename ::boost::move_detail::forward_type< P5 >::type , typename ::boost::move_detail::forward_type< P6 >::type , typename ::boost::move_detail::forward_type< P7 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type , typename ::boost::move_detail::forward_type< P4 >::type , typename ::boost::move_detail::forward_type< P5 >::type , typename ::boost::move_detail::forward_type< P6 >::type , typename ::boost::move_detail::forward_type< P7 >::type , typename ::boost::move_detail::forward_type< P8 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 )); }


        template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > static void priv_construct(boost::false_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9) { const bool value = boost::container::container_detail::has_member_function_callable_with_construct < Alloc, T* , typename ::boost::move_detail::forward_type< P0 >::type , typename ::boost::move_detail::forward_type< P1 >::type , typename ::boost::move_detail::forward_type< P2 >::type , typename ::boost::move_detail::forward_type< P3 >::type , typename ::boost::move_detail::forward_type< P4 >::type , typename ::boost::move_detail::forward_type< P5 >::type , typename ::boost::move_detail::forward_type< P6 >::type , typename ::boost::move_detail::forward_type< P7 >::type , typename ::boost::move_detail::forward_type< P8 >::type , typename ::boost::move_detail::forward_type< P9 >::type >::value; ::boost::integral_constant<bool, value> flag; priv_construct_dispatch2(flag, a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > static void priv_construct(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9) { priv_construct_dispatch2(boost::false_type(), a, p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > static void priv_construct_dispatch2(boost::true_type, Alloc &a, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9) { a.construct( p , ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 ) ); } template<class T , class P0 , class P1 , class P2 , class P3 , class P4 , class P5 , class P6 , class P7 , class P8 , class P9 > static void priv_construct_dispatch2(boost::false_type, Alloc &, T *p , const P0 & p0 , const P1 & p1 , const P2 & p2 , const P3 & p3 , const P4 & p4 , const P5 & p5 , const P6 & p6 , const P7 & p7 , const P8 & p8 , const P9 & p9 ) { ::new((void*)p) T( ::boost::forward< P0 >( p0 ) , ::boost::forward< P1 >( p1 ) , ::boost::forward< P2 >( p2 ) , ::boost::forward< P3 >( p3 ) , ::boost::forward< P4 >( p4 ) , ::boost::forward< P5 >( p5 ) , ::boost::forward< P6 >( p6 ) , ::boost::forward< P7 >( p7 ) , ::boost::forward< P8 >( p8 ) , ::boost::forward< P9 >( p9 )); }
# 374 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 2




};

}
}

# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 384 "/opt/sevenflow/boost/include/boost/container/allocator_traits.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 2


namespace boost {
namespace container {
namespace container_detail {

template <typename T>
inline T* addressof(T& obj)
{
   return static_cast<T*>(
    static_cast<void*>(
       const_cast<char*>(
            &reinterpret_cast<const char&>(obj)
   )));
}

template<class T>
const T &max_value(const T &a, const T &b)
{ return a > b ? a : b; }

template<class T>
const T &min_value(const T &a, const T &b)
{ return a < b ? a : b; }

template <class SizeType>
SizeType
   get_next_capacity(const SizeType max_size
                    ,const SizeType capacity
                    ,const SizeType n)
{



   const SizeType m3 = max_size/3;

   if (capacity < m3)
      return capacity + max_value(3*(capacity+1)/5, n);

   if (capacity < m3*2)
      return capacity + max_value((capacity+1)/2, n);

   return max_size;
}

template <class T>
inline T* to_raw_pointer(T* p)
{ return p; }

template <class Pointer>
inline typename Pointer::element_type*
   to_raw_pointer(const Pointer &p)
{ return boost::container::container_detail::to_raw_pointer(p.operator->()); }


template <class T>
inline void do_swap(T& x, T& y)
{
   using std::swap;
   swap(x, y);
}

template<class AllocatorType>
inline void swap_alloc(AllocatorType &, AllocatorType &, container_detail::false_type)
  
{}

template<class AllocatorType>
inline void swap_alloc(AllocatorType &l, AllocatorType &r, container_detail::true_type)
{ container_detail::do_swap(l, r); }

template<class AllocatorType>
inline void assign_alloc(AllocatorType &, const AllocatorType &, container_detail::false_type)
  
{}

template<class AllocatorType>
inline void assign_alloc(AllocatorType &l, const AllocatorType &r, container_detail::true_type)
{ l = r; }

template<class AllocatorType>
inline void move_alloc(AllocatorType &, AllocatorType &, container_detail::false_type)
  
{}

template<class AllocatorType>
inline void move_alloc(AllocatorType &l, AllocatorType &r, container_detail::true_type)
{ l = ::boost::move(r); }


template<class SizeType>
inline SizeType get_rounded_size(SizeType orig_size, SizeType round_to)
{
   return ((orig_size-1)/round_to+1)*round_to;
}

template <std::size_t OrigSize, std::size_t RoundTo>
struct ct_rounded_size
{
   enum { value = ((OrigSize-1)/RoundTo+1)*RoundTo };
};
# 156 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp"
template<class T>
struct move_const_ref_type
   : if_c

   < !::boost::is_class<T>::value
   ,const T &
   ,const ::boost::rv< T >&
   >
{};

}
# 181 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp"
template
   <typename A,
    typename I,
    typename F>
F uninitialized_move_alloc(A &a, I f, I l, F r)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), boost::move(*f));
      ++f; ++r;
   }
   return r;
}
# 207 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp"
template
   <typename A,
    typename I,
    typename F>
F uninitialized_copy_alloc(A &a, I f, I l, F r)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), *f);
      ++f; ++r;
   }
   return r;
}
# 233 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp"
template
   <typename A,
    typename F,
    typename T>
void uninitialized_fill_alloc(A &a, F f, F l, const T &t)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*f), t);
      ++f;
   }
}







template
<typename A
,typename I
,typename F>
F uninitialized_copy_or_move_alloc
   (A &a, I f, I l, F r
   ,typename boost::container::container_detail::enable_if
      < boost::move_detail::is_move_iterator<I> >::type* = 0)
{
   return ::boost::container::uninitialized_move_alloc(a, f, l, r);
}

template
<typename A
,typename I
,typename F>
F uninitialized_copy_or_move_alloc
   (A &a, I f, I l, F r
   ,typename boost::container::container_detail::disable_if
      < boost::move_detail::is_move_iterator<I> >::type* = 0)
{
   return ::boost::container::uninitialized_copy_alloc(a, f, l, r);
}


}
}


# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 281 "/opt/sevenflow/boost/include/boost/container/detail/utilities.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/container/detail/transform_iterator.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/container/detail/transform_iterator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_begin.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/container/detail/transform_iterator.hpp" 2




namespace boost {
namespace container {

template <class PseudoReference>
struct operator_arrow_proxy
{
   operator_arrow_proxy(const PseudoReference &px)
      : m_value(px)
   {}

   PseudoReference* operator->() const { return &m_value; }



   mutable PseudoReference m_value;
};

template <class T>
struct operator_arrow_proxy<T&>
{
   operator_arrow_proxy(T &px)
      : m_value(px)
   {}

   T* operator->() const { return const_cast<T*>(&m_value); }



   T &m_value;
};

template <class Iterator, class UnaryFunction>
class transform_iterator
   : public UnaryFunction
   , public std::iterator
      < typename Iterator::iterator_category
      , typename container_detail::remove_reference<typename UnaryFunction::result_type>::type
      , typename Iterator::difference_type
      , operator_arrow_proxy<typename UnaryFunction::result_type>
      , typename UnaryFunction::result_type>
{
   public:
   explicit transform_iterator(const Iterator &it, const UnaryFunction &f = UnaryFunction())
      : UnaryFunction(f), m_it(it)
   {}

   explicit transform_iterator()
      : UnaryFunction(), m_it()
   {}


   transform_iterator& operator++()
   { increment(); return *this; }

   transform_iterator operator++(int)
   {
      transform_iterator result (*this);
      increment();
      return result;
   }

   friend bool operator== (const transform_iterator& i, const transform_iterator& i2)
   { return i.equal(i2); }

   friend bool operator!= (const transform_iterator& i, const transform_iterator& i2)
   { return !(i == i2); }
# 103 "/opt/sevenflow/boost/include/boost/container/detail/transform_iterator.hpp"
   friend typename Iterator::difference_type operator- (const transform_iterator& i, const transform_iterator& i2)
   { return i2.distance_to(i); }


   transform_iterator& operator+=(typename Iterator::difference_type off)
   { this->advance(off); return *this; }

   transform_iterator operator+(typename Iterator::difference_type off) const
   {
      transform_iterator other(*this);
      other.advance(off);
      return other;
   }

   friend transform_iterator operator+(typename Iterator::difference_type off, const transform_iterator& right)
   { return right + off; }

   transform_iterator& operator-=(typename Iterator::difference_type off)
   { this->advance(-off); return *this; }

   transform_iterator operator-(typename Iterator::difference_type off) const
   { return *this + (-off); }

   typename UnaryFunction::result_type operator*() const
   { return dereference(); }

   operator_arrow_proxy<typename UnaryFunction::result_type>
      operator->() const
   { return operator_arrow_proxy<typename UnaryFunction::result_type>(dereference()); }

   Iterator & base()
   { return m_it; }

   const Iterator & base() const
   { return m_it; }

   private:
   Iterator m_it;

   void increment()
   { ++m_it; }

   void decrement()
   { --m_it; }

   bool equal(const transform_iterator &other) const
   { return m_it == other.m_it; }

   bool less(const transform_iterator &other) const
   { return other.m_it < m_it; }

   typename UnaryFunction::result_type dereference() const
   { return UnaryFunction::operator()(*m_it); }

   void advance(typename Iterator::difference_type n)
   { std::advance(m_it, n); }

   typename Iterator::difference_type distance_to(const transform_iterator &other)const
   { return std::distance(other.m_it, m_it); }
};

template <class Iterator, class UnaryFunc>
transform_iterator<Iterator, UnaryFunc>
make_transform_iterator(Iterator it, UnaryFunc fun)
{
   return transform_iterator<Iterator, UnaryFunc>(it, fun);
}

}
}

# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 175 "/opt/sevenflow/boost/include/boost/container/detail/transform_iterator.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/slist_node.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/slist_node.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/detail/slist_node.hpp" 2




namespace boost {
namespace intrusive {

template<class VoidPointer>
struct slist_node
{
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<slist_node>::type node_ptr;
   node_ptr next_;
};




template<class VoidPointer>
struct slist_node_traits
{
   typedef slist_node<VoidPointer> node;
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<node>::type node_ptr;
   typedef typename pointer_traits
      <VoidPointer>::template rebind_pointer<const node>::type const_node_ptr;

   static const node_ptr &get_next(const const_node_ptr & n)
   { return n->next_; }

   static void set_next(const node_ptr & n, const node_ptr & next)
   { n->next_ = next; }
};



template<class Container, bool IsConst>
class slist_iterator
   : public std::iterator
         < std::forward_iterator_tag
         , typename Container::value_type
         , typename Container::difference_type
         , typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type
         , typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type
         >
{
   protected:
   typedef typename Container::real_value_traits real_value_traits;
   typedef typename real_value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename pointer_traits
      <node_ptr>::template rebind_pointer <void>::type void_pointer;
   static const bool store_container_ptr =
      detail::store_cont_ptr_on_it<Container>::value;

   public:
   typedef typename Container::value_type value_type;
   typedef typename detail::if_c<IsConst,typename Container::const_pointer,typename Container::pointer>::type pointer;
   typedef typename detail::if_c<IsConst,typename Container::const_reference,typename Container::reference>::type reference;

   slist_iterator()
      : members_ (node_ptr(), 0)
   {}

   explicit slist_iterator(const node_ptr & node, const Container *cont_ptr)
      : members_ (node, cont_ptr)
   {}

   slist_iterator(slist_iterator<Container, false> const& other)
      : members_(other.pointed_node(), other.get_container())
   {}

   const node_ptr &pointed_node() const
   { return members_.nodeptr_; }

   slist_iterator &operator=(const node_ptr &node)
   { members_.nodeptr_ = node; return static_cast<slist_iterator&>(*this); }

   public:
   slist_iterator& operator++()
   {
      members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
      return static_cast<slist_iterator&> (*this);
   }

   slist_iterator operator++(int)
   {
      slist_iterator result (*this);
      members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
      return result;
   }

   friend bool operator== (const slist_iterator& l, const slist_iterator& r)
   { return l.pointed_node() == r.pointed_node(); }

   friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
   { return !(l == r); }

   reference operator*() const
   { return *operator->(); }

   pointer operator->() const
   { return this->get_real_value_traits()->to_value_ptr(members_.nodeptr_); }

   const Container *get_container() const
   {
      if(store_container_ptr)
         return static_cast<const Container*>(members_.get_ptr());
      else
         return 0;
   }

   slist_iterator<Container, false> unconst() const
   { return slist_iterator<Container, false>(this->pointed_node(), this->get_container()); }

   const real_value_traits *get_real_value_traits() const
   {
      if(store_container_ptr)
         return &this->get_container()->get_real_value_traits();
      else
         return 0;
   }

   private:
   struct members
      : public detail::select_constptr
         <void_pointer, store_container_ptr>::type
   {
      typedef typename detail::select_constptr
         <void_pointer, store_container_ptr>::type Base;

      members(const node_ptr &n_ptr, const void *cont)
         : Base(cont), nodeptr_(n_ptr)
      {}

      node_ptr nodeptr_;
   } members_;
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 162 "/opt/sevenflow/boost/include/boost/intrusive/detail/slist_node.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/common_slist_algorithms.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/intrusive/detail/common_slist_algorithms.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/detail/common_slist_algorithms.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/intrusive/detail/common_slist_algorithms.hpp" 2

namespace boost {
namespace intrusive {
namespace detail {

template<class NodeTraits>
class common_slist_algorithms
{
   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;

   static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
   {
      node_ptr p = prev_init_node;
      for( node_ptr p_next
         ; this_node != (p_next = NodeTraits::get_next(p))
         ; p = p_next){


         ((p) ? static_cast<void> (0) : __assert_fail ("p", "/opt/sevenflow/boost/include/boost/intrusive/detail/common_slist_algorithms.hpp", 42, __PRETTY_FUNCTION__));
      }
      return p;
   }

   static void init_header(const node_ptr & this_node)
   { NodeTraits::set_next(this_node, this_node); }

   static void init(const node_ptr & this_node)
   { NodeTraits::set_next(this_node, node_ptr()); }

   static bool unique(const const_node_ptr & this_node)
   {
      node_ptr next = NodeTraits::get_next(this_node);
      return !next || next == this_node;
   }

   static bool inited(const const_node_ptr & this_node)
   { return !NodeTraits::get_next(this_node); }

   static void unlink_after(const node_ptr & prev_node)
   {
      const_node_ptr this_node(NodeTraits::get_next(prev_node));
      NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
   }

   static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node)
   { NodeTraits::set_next(prev_node, last_node); }

   static void link_after(const node_ptr & prev_node, const node_ptr & this_node)
   {
      NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node));
      NodeTraits::set_next(prev_node, this_node);
   }

   static void incorporate_after(const node_ptr & bp, const node_ptr & b, const node_ptr & be)
   {
      node_ptr p(NodeTraits::get_next(bp));
      NodeTraits::set_next(bp, b);
      NodeTraits::set_next(be, p);
   }

   static void transfer_after(const node_ptr & bp, const node_ptr & bb, const node_ptr & be)
   {
      if (bp != bb && bp != be && bb != be) {
         node_ptr next_b = NodeTraits::get_next(bb);
         node_ptr next_e = NodeTraits::get_next(be);
         node_ptr next_p = NodeTraits::get_next(bp);
         NodeTraits::set_next(bb, next_e);
         NodeTraits::set_next(be, next_p);
         NodeTraits::set_next(bp, next_b);
      }
   }
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 102 "/opt/sevenflow/boost/include/boost/intrusive/detail/common_slist_algorithms.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 22 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp" 2

namespace boost {
namespace intrusive {
# 47 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
template<class NodeTraits>
class circular_slist_algorithms

   : public detail::common_slist_algorithms<NodeTraits>

{

   typedef detail::common_slist_algorithms<NodeTraits> base_t;

   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;
# 140 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static void init_header(const node_ptr &this_node)
   { NodeTraits::set_next(this_node, this_node); }
# 152 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static node_ptr get_previous_node(const node_ptr &prev_init_node, const node_ptr &this_node)
   { return base_t::get_previous_node(prev_init_node, this_node); }
# 162 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static node_ptr get_previous_node(const node_ptr & this_node)
   { return base_t::get_previous_node(this_node, this_node); }
# 172 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static node_ptr get_previous_previous_node(const node_ptr & this_node)
   { return get_previous_previous_node(this_node, this_node); }
# 184 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static node_ptr get_previous_previous_node(const node_ptr & prev_prev_init_node, const node_ptr & this_node)
   {
      node_ptr p = prev_prev_init_node;
      node_ptr p_next = NodeTraits::get_next(p);
      node_ptr p_next_next = NodeTraits::get_next(p_next);
      while (this_node != p_next_next){
         p = p_next;
         p_next = p_next_next;
         p_next_next = NodeTraits::get_next(p_next);
      }
      return p;
   }
# 205 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static std::size_t count(const const_node_ptr & this_node)
   {
      std::size_t result = 0;
      const_node_ptr p = this_node;
      do{
         p = NodeTraits::get_next(p);
         ++result;
      } while (p != this_node);
      return result;
   }
# 223 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static void unlink(const node_ptr & this_node)
   {
      if(NodeTraits::get_next(this_node))
         base_t::unlink_after(get_previous_node(this_node));
   }
# 236 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static void link_before (const node_ptr & nxt_node, const node_ptr & this_node)
   { base_t::link_after(get_previous_node(nxt_node), this_node); }
# 249 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static void swap_nodes(const node_ptr & this_node, const node_ptr & other_node)
   {
      if (other_node == this_node)
         return;
      bool this_inited = base_t::inited(this_node);
      bool other_inited = base_t::inited(other_node);
      if(this_inited){
         base_t::init_header(this_node);
      }
      if(other_inited){
         base_t::init_header(other_node);
      }

      bool empty1 = base_t::unique(this_node);
      bool empty2 = base_t::unique(other_node);
      node_ptr prev_this (get_previous_node(this_node));
      node_ptr prev_other(get_previous_node(other_node));

      node_ptr this_next (NodeTraits::get_next(this_node));
      node_ptr other_next(NodeTraits::get_next(other_node));
      NodeTraits::set_next(this_node, other_next);
      NodeTraits::set_next(other_node, this_next);
      NodeTraits::set_next(empty1 ? other_node : prev_this, other_node);
      NodeTraits::set_next(empty2 ? this_node : prev_other, this_node);

      if(this_inited){
         base_t::init(other_node);
      }
      if(other_inited){
         base_t::init(this_node);
      }
   }






   static void reverse(const node_ptr & p)
   {
      node_ptr i = NodeTraits::get_next(p), e(p);
      for (;;) {
         node_ptr nxt(NodeTraits::get_next(i));
         if (nxt == e)
            break;
         base_t::transfer_after(e, i, nxt);
      }
   }
# 306 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static node_ptr move_backwards(const node_ptr & p, std::size_t n)
   {

      if(!n) return node_ptr();
      node_ptr first = NodeTraits::get_next(p);


      if(NodeTraits::get_next(first) == p)
         return node_ptr();

      bool end_found = false;
      node_ptr new_last = node_ptr();





      for(std::size_t i = 1; i <= n; ++i){
         new_last = first;
         first = NodeTraits::get_next(first);
         if(first == p){

            n %= i;
            if(!n)
               return node_ptr();
            i = 0;

            first = NodeTraits::get_next(p);
            base_t::unlink_after(new_last);
            end_found = true;
         }
      }



      if(!end_found){
         base_t::unlink_after(base_t::get_previous_node(first, p));
      }


      base_t::link_after(new_last, p);
      return new_last;
   }
# 358 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp"
   static node_ptr move_forward(const node_ptr & p, std::size_t n)
   {

      if(!n) return node_ptr();
      node_ptr first = node_traits::get_next(p);


      if(node_traits::get_next(first) == p) return node_ptr();




      node_ptr old_last(first), next_to_it, new_last(p);
      std::size_t distance = 1;
      while(p != (next_to_it = node_traits::get_next(old_last))){
         if(++distance > n)
            new_last = node_traits::get_next(new_last);
         old_last = next_to_it;
      }


      if(distance <= n){


         std::size_t new_before_last_pos = (distance - (n % distance))% distance;

         if(!new_before_last_pos) return node_ptr();

         for( new_last = p
            ; new_before_last_pos--
            ; new_last = node_traits::get_next(new_last)){

         }
      }


      base_t::unlink_after(old_last);
      base_t::link_after(new_last, p);
      return new_last;
   }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 404 "/opt/sevenflow/boost/include/boost/intrusive/circular_slist_algorithms.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp" 2




namespace boost {
namespace intrusive {


template<class VoidPointer>
struct get_slist_node_algo
{
   typedef circular_slist_algorithms<slist_node_traits<VoidPointer> > type;
};
# 43 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp"
template<class O1 = none, class O2 = none, class O3 = none>

struct make_slist_base_hook
{

   typedef typename pack_options
      < hook_defaults,

         O1, O2, O3



      >::type packed_options;

   typedef detail::generic_hook
   < get_slist_node_algo<typename packed_options::void_pointer>
   , typename packed_options::tag
   , packed_options::link_mode
   , detail::SlistBaseHook
   > implementation_defined;

   typedef implementation_defined type;
};
# 87 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp"
template<class O1, class O2, class O3>

class slist_base_hook
   : public make_slist_base_hook<

         O1, O2, O3



      >::type
{
# 164 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp"
};






template<class O1 = none, class O2 = none, class O3 = none>

struct make_slist_member_hook
{

   typedef typename pack_options
      < hook_defaults,

         O1, O2, O3



      >::type packed_options;

   typedef detail::generic_hook
   < get_slist_node_algo<typename packed_options::void_pointer>
   , member_tag
   , packed_options::link_mode
   , detail::NoBaseHook
   > implementation_defined;

   typedef implementation_defined type;
};
# 210 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp"
template<class O1, class O2, class O3>

class slist_member_hook
   : public make_slist_member_hook<

         O1, O2, O3



      >::type
{
# 287 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp"
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 293 "/opt/sevenflow/boost/include/boost/intrusive/slist_hook.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_begin.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp" 2


namespace boost {
namespace intrusive {
# 46 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
template<class NodeTraits>
class linear_slist_algorithms

   : public detail::common_slist_algorithms<NodeTraits>

{

   typedef detail::common_slist_algorithms<NodeTraits> base_t;

   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;
# 139 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static void init_header(const node_ptr & this_node)
   { NodeTraits::set_next(this_node, node_ptr ()); }
# 151 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static node_ptr get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node)
   { return base_t::get_previous_node(prev_init_node, this_node); }
# 162 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static std::size_t count(const const_node_ptr & this_node)
   {
      std::size_t result = 0;
      const_node_ptr p = this_node;
      do{
         p = NodeTraits::get_next(p);
         ++result;
      } while (p);
      return result;
   }
# 182 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static void swap_trailing_nodes(const node_ptr & this_node, const node_ptr & other_node)
   {
      node_ptr this_nxt = NodeTraits::get_next(this_node);
      node_ptr other_nxt = NodeTraits::get_next(other_node);
      NodeTraits::set_next(this_node, other_nxt);
      NodeTraits::set_next(other_node, this_nxt);
   }
# 197 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static node_ptr reverse(const node_ptr & p)
   {
      if(!p) return node_ptr();
      node_ptr i = NodeTraits::get_next(p);
      node_ptr first(p);
      while(i){
         node_ptr nxti(NodeTraits::get_next(i));
         base_t::unlink_after(p);
         NodeTraits::set_next(i, first);
         first = i;
         i = nxti;
      }
      return first;
   }
# 220 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static std::pair<node_ptr, node_ptr> move_first_n_backwards(const node_ptr & p, std::size_t n)
   {
      std::pair<node_ptr, node_ptr> ret;

      if(!n || !p || !NodeTraits::get_next(p)){
         return ret;
      }

      node_ptr first = p;
      bool end_found = false;
      node_ptr new_last = node_ptr();
      node_ptr old_last = node_ptr();





      for(std::size_t i = 1; i <= n; ++i){
         new_last = first;
         first = NodeTraits::get_next(first);
         if(first == node_ptr()){

            n %= i;
            if(!n) return ret;
            old_last = new_last;
            i = 0;

            first = p;

            end_found = true;
         }
      }



      if(!end_found){
         old_last = base_t::get_previous_node(first, node_ptr());
      }


      NodeTraits::set_next(old_last, p);
      NodeTraits::set_next(new_last, node_ptr());
      ret.first = first;
      ret.second = new_last;
      return ret;
   }
# 275 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp"
   static std::pair<node_ptr, node_ptr> move_first_n_forward(const node_ptr & p, std::size_t n)
   {
      std::pair<node_ptr, node_ptr> ret;

      if(!n || !p || !NodeTraits::get_next(p))
         return ret;

      node_ptr first = p;




      node_ptr old_last(first), next_to_it, new_last(p);
      std::size_t distance = 1;
      while(!!(next_to_it = node_traits::get_next(old_last))){
         if(distance++ > n)
            new_last = node_traits::get_next(new_last);
         old_last = next_to_it;
      }


      if(distance <= n){


         std::size_t new_before_last_pos = (distance - (n % distance))% distance;

         if(!new_before_last_pos)
            return ret;

         for( new_last = p
            ; --new_before_last_pos
            ; new_last = node_traits::get_next(new_last)){

         }
      }


      node_ptr new_first(node_traits::get_next(new_last));

      NodeTraits::set_next(old_last, p);
      NodeTraits::set_next(new_last, node_ptr());
      ret.first = new_first;
      ret.second = new_last;
      return ret;
   }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 326 "/opt/sevenflow/boost/include/boost/intrusive/linear_slist_algorithms.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 33 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp" 2



namespace boost {
namespace intrusive {



template <class ValueTraits, class SizeType, bool ConstantTimeSize, bool Linear, bool CacheLast>
struct slistopt
{
   typedef ValueTraits value_traits;
   typedef SizeType size_type;
   static const bool constant_time_size = ConstantTimeSize;
   static const bool linear = Linear;
   static const bool cache_last = CacheLast;
};

template<class Node, class NodePtr, bool>
struct root_plus_last
{
   Node root_;
   NodePtr last_;
};

template<class Node, class NodePtr>
struct root_plus_last<Node, NodePtr, false>
{
   Node root_;
};

template <class T>
struct slist_defaults
   : pack_options
      < none
      , base_hook<detail::default_slist_hook>
      , constant_time_size<true>
      , linear<false>
      , size_type<std::size_t>
      , cache_last<false>
      >::type
{};
# 104 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
template<class Config>

class slist_impl
   : private detail::clear_on_destructor_base<slist_impl<Config> >
{
   template<class C> friend class detail::clear_on_destructor_base;

   public:
   typedef typename Config::value_traits value_traits;

   static const bool external_value_traits =
      detail::external_value_traits_is_true<value_traits>::value;
   typedef typename detail::eval_if_c
      < external_value_traits
      , detail::eval_value_traits<value_traits>
      , detail::identity<value_traits>
      >::type real_value_traits;

   typedef typename real_value_traits::pointer pointer;
   typedef typename real_value_traits::const_pointer const_pointer;
   typedef typename pointer_traits<pointer>::element_type value_type;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits<const_pointer>::reference const_reference;
   typedef typename pointer_traits<pointer>::difference_type difference_type;
   typedef typename Config::size_type size_type;
   typedef slist_iterator<slist_impl, false> iterator;
   typedef slist_iterator<slist_impl, true> const_iterator;
   typedef typename real_value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;

   typedef typename detail::if_c
      < Config::linear
      , linear_slist_algorithms<node_traits>
      , circular_slist_algorithms<node_traits>
      >::type node_algorithms;

   static const bool constant_time_size = Config::constant_time_size;
   static const bool stateful_value_traits = detail::is_stateful_value_traits<real_value_traits>::value;
   static const bool linear = Config::linear;
   static const bool cache_last = Config::cache_last;


   private:
   typedef detail::size_holder<constant_time_size, size_type> size_traits;


   private: slist_impl(slist_impl &); slist_impl& operator=(slist_impl &); public: operator ::boost::rv<slist_impl>&() { return *static_cast< ::boost::rv<slist_impl>* >(this); } operator const ::boost::rv<slist_impl>&() const { return *static_cast<const ::boost::rv<slist_impl>* >(this); } private:

   enum { safemode_or_autounlink =
            (int)real_value_traits::link_mode == (int)auto_unlink ||
            (int)real_value_traits::link_mode == (int)safe_link };


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!(constant_time_size && ((int)real_value_traits::link_mode == (int)auto_unlink))) == 0 ? false : true) >)> boost_static_assert_typedef_159;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!(linear && ((int)real_value_traits::link_mode == (int)auto_unlink))) == 0 ? false : true) >)> boost_static_assert_typedef_161;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!(cache_last && ((int)real_value_traits::link_mode == (int)auto_unlink))) == 0 ? false : true) >)> boost_static_assert_typedef_163;

   node_ptr get_end_node()
   { return node_ptr(linear ? node_ptr() : this->get_root_node()); }

   const_node_ptr get_end_node() const
   {
      return const_node_ptr
         (linear ? const_node_ptr() : this->get_root_node()); }

   node_ptr get_root_node()
   { return pointer_traits<node_ptr>::pointer_to(data_.root_plus_size_.root_); }

   const_node_ptr get_root_node() const
   { return pointer_traits<const_node_ptr>::pointer_to(data_.root_plus_size_.root_); }

   node_ptr get_last_node()
   { return this->get_last_node(detail::bool_<cache_last>()); }

   const_node_ptr get_last_node() const
   { return this->get_last_node(detail::bool_<cache_last>()); }

   void set_last_node(const node_ptr &n)
   { return this->set_last_node(n, detail::bool_<cache_last>()); }

   static node_ptr get_last_node(detail::bool_<false>)
   { return node_ptr(); }

   static void set_last_node(const node_ptr &, detail::bool_<false>)
   {}

   node_ptr get_last_node(detail::bool_<true>)
   { return node_ptr(data_.root_plus_size_.last_); }

   const_node_ptr get_last_node(detail::bool_<true>) const
   { return const_node_ptr(data_.root_plus_size_.last_); }

   void set_last_node(const node_ptr & n, detail::bool_<true>)
   { data_.root_plus_size_.last_ = n; }

   static node_ptr uncast(const const_node_ptr & ptr)
   { return pointer_traits<node_ptr>::const_cast_from(ptr); }

   void set_default_constructed_state()
   {
      node_algorithms::init_header(this->get_root_node());
      this->priv_size_traits().set_size(size_type(0));
      if(cache_last){
         this->set_last_node(this->get_root_node());
      }
   }

   struct root_plus_size
      : public size_traits
      , public root_plus_last<node, node_ptr, cache_last>
   {};

   struct data_t
      : public slist_impl::value_traits
   {
      typedef typename slist_impl::value_traits value_traits;
      data_t(const value_traits &val_traits)
         : value_traits(val_traits)
      {}

      root_plus_size root_plus_size_;
   } data_;

   size_traits &priv_size_traits()
   { return data_.root_plus_size_; }

   const size_traits &priv_size_traits() const
   { return data_.root_plus_size_; }

   const real_value_traits &get_real_value_traits(detail::bool_<false>) const
   { return data_; }

   const real_value_traits &get_real_value_traits(detail::bool_<true>) const
   { return data_.get_value_traits(*this); }

   real_value_traits &get_real_value_traits(detail::bool_<false>)
   { return data_; }

   real_value_traits &get_real_value_traits(detail::bool_<true>)
   { return data_.get_value_traits(*this); }

   const value_traits &priv_value_traits() const
   { return data_; }

   value_traits &priv_value_traits()
   { return data_; }

   protected:
   node &prot_root_node()
   { return data_.root_plus_size_.root_; }

   node const &prot_root_node() const
   { return data_.root_plus_size_.root_; }

   void prot_set_size(size_type s)
   { data_.root_plus_size_.set_size(s); }



   public:

   const real_value_traits &get_real_value_traits() const
   { return this->get_real_value_traits(detail::bool_<external_value_traits>()); }

   real_value_traits &get_real_value_traits()
   { return this->get_real_value_traits(detail::bool_<external_value_traits>()); }

   public:






   slist_impl(const value_traits &v_traits = value_traits())
      : data_(v_traits)
   { this->set_default_constructed_state(); }
# 294 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Iterator>
   slist_impl(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
      : data_(v_traits)
   {
      this->set_default_constructed_state();
      this->insert_after(this->cbefore_begin(), b, e);
   }



   slist_impl(::boost::rv< slist_impl >& x)
      : data_(::boost::move(x.priv_value_traits()))
   {
      this->priv_size_traits().set_size(size_type(0));
      node_algorithms::init_header(this->get_root_node());
      this->swap(x);
   }



   slist_impl& operator=(::boost::rv< slist_impl >& x)
   { this->swap(x); return *this; }
# 326 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   ~slist_impl()
   {}
# 337 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void clear()
   {
      if(safemode_or_autounlink){
         this->clear_and_dispose(detail::null_disposer());
      }
      else{
         this->set_default_constructed_state();
      }
   }
# 357 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template <class Disposer>
   void clear_and_dispose(Disposer disposer)
   {
      const_iterator it(this->begin()), itend(this->end());
      while(it != itend){
         node_ptr to_erase(it.pointed_node());
         ++it;
         if(safemode_or_autounlink)
            node_algorithms::init(to_erase);
         disposer(get_real_value_traits().to_value_ptr(to_erase));
      }
      this->set_default_constructed_state();
   }
# 381 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void push_front(reference value)
   {
      node_ptr to_insert = get_real_value_traits().to_node_ptr(value);
      if(safemode_or_autounlink)
         ((node_algorithms::inited(to_insert)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::inited(to_insert)", "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp", 385, __PRETTY_FUNCTION__));
      if(cache_last){
         if(this->empty()){
            this->set_last_node(to_insert);
         }
      }
      node_algorithms::link_after(this->get_root_node(), to_insert);
      this->priv_size_traits().increment();
   }
# 406 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void push_back(reference value)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((cache_last)) == 0 ? false : true) >)> boost_static_assert_typedef_408;
      this->insert_after(const_iterator(this->get_last_node(), this), value);
   }
# 420 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void pop_front()
   { return this->pop_front_and_dispose(detail::null_disposer()); }
# 433 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   void pop_front_and_dispose(Disposer disposer)
   {
      node_ptr to_erase = node_traits::get_next(this->get_root_node());
      node_algorithms::unlink_after(this->get_root_node());
      this->priv_size_traits().decrement();
      if(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(get_real_value_traits().to_value_ptr(to_erase));
      if(cache_last){
         if(this->empty()){
            this->set_last_node(this->get_root_node());
         }
      }
   }






   reference front()
   { return *this->get_real_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }






   const_reference front() const
   { return *this->get_real_value_traits().to_value_ptr(uncast(node_traits::get_next(this->get_root_node()))); }
# 473 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   reference back()
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((cache_last)) == 0 ? false : true) >)> boost_static_assert_typedef_475;
      return *this->get_real_value_traits().to_value_ptr(this->get_last_node());
   }
# 487 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   const_reference back() const
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((cache_last)) == 0 ? false : true) >)> boost_static_assert_typedef_489;
      return *this->get_real_value_traits().to_value_ptr(this->get_last_node());
   }






   iterator begin()
   { return iterator (node_traits::get_next(this->get_root_node()), this); }






   const_iterator begin() const
   { return const_iterator (node_traits::get_next(this->get_root_node()), this); }






   const_iterator cbegin() const
   { return const_iterator(node_traits::get_next(this->get_root_node()), this); }






   iterator end()
   { return iterator(this->get_end_node(), this); }






   const_iterator end() const
   { return const_iterator(uncast(this->get_end_node()), this); }






   const_iterator cend() const
   { return this->end(); }







   iterator before_begin()
   { return iterator(this->get_root_node(), this); }







   const_iterator before_begin() const
   { return const_iterator(uncast(this->get_root_node()), this); }







   const_iterator cbefore_begin() const
   { return this->before_begin(); }
# 575 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator last()
   { return iterator (this->get_last_node(), this); }
# 585 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   const_iterator last() const
   { return const_iterator (this->get_last_node(), this); }
# 595 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   const_iterator clast() const
   { return const_iterator(this->get_last_node(), this); }
# 606 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   static slist_impl &container_from_end_iterator(iterator end_iterator)
   { return slist_impl::priv_container_from_end_iterator(end_iterator); }
# 617 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   static const slist_impl &container_from_end_iterator(const_iterator end_iterator)
   { return slist_impl::priv_container_from_end_iterator(end_iterator); }
# 628 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   size_type size() const
   {
      if(constant_time_size)
         return this->priv_size_traits().get_size();
      else
         return node_algorithms::count(this->get_root_node()) - 1;
   }
# 643 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   bool empty() const
   { return node_algorithms::unique(this->get_root_node()); }
# 654 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void swap(slist_impl& other)
   {
      if(cache_last){
         priv_swap_cache_last(this, &other);
      }
      else{
         this->priv_swap_lists(this->get_root_node(), other.get_root_node(), detail::bool_<linear>());
      }
      if(constant_time_size){
         size_type backup = this->priv_size_traits().get_size();
         this->priv_size_traits().set_size(other.priv_size_traits().get_size());
         other.priv_size_traits().set_size(backup);
      }
   }
# 678 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void shift_backwards(size_type n = 1)
   { this->priv_shift_backwards(n, detail::bool_<linear>()); }
# 690 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void shift_forward(size_type n = 1)
   { this->priv_shift_forward(n, detail::bool_<linear>()); }
# 707 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template <class Cloner, class Disposer>
   void clone_from(const slist_impl &src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      detail::exception_disposer<slist_impl, Disposer>
         rollback(*this, disposer);
      const_iterator prev(this->cbefore_begin());
      const_iterator b(src.begin()), e(src.end());
      for(; b != e; ++b){
         prev = this->insert_after(prev, *cloner(*b));
      }
      rollback.release();
   }
# 734 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator insert_after(const_iterator prev_p, reference value)
   {
      node_ptr n = get_real_value_traits().to_node_ptr(value);
      if(safemode_or_autounlink)
         ((node_algorithms::inited(n)) ? static_cast<void> (0) : __assert_fail ("node_algorithms::inited(n)", "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp", 738, __PRETTY_FUNCTION__));
      node_ptr prev_n(prev_p.pointed_node());
      node_algorithms::link_after(prev_n, n);
      if(cache_last && (this->get_last_node() == prev_n)){
         this->set_last_node(n);
      }
      this->priv_size_traits().increment();
      return iterator (n, this);
   }
# 760 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Iterator>
   void insert_after(const_iterator prev_p, Iterator first, Iterator last)
   {
      for (; first != last; ++first)
         prev_p = this->insert_after(prev_p, *first);
   }
# 779 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator insert(const_iterator p, reference value)
   { return this->insert_after(this->previous(p), value); }
# 796 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Iterator>
   void insert(const_iterator p, Iterator b, Iterator e)
   { return this->insert_after(this->previous(p), b, e); }
# 812 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator erase_after(const_iterator prev)
   { return this->erase_after_and_dispose(prev, detail::null_disposer()); }
# 828 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator erase_after(const_iterator before_first, const_iterator last)
   {
      if(safemode_or_autounlink || constant_time_size){
         return this->erase_after_and_dispose(before_first, last, detail::null_disposer());
      }
      else{
         node_ptr bfp = before_first.pointed_node();
         node_ptr lp = last.pointed_node();
         if(cache_last){
            if(lp == this->get_end_node()){
               this->set_last_node(bfp);
            }
         }
         node_algorithms::unlink_after(bfp, lp);
         return last.unconst();
      }
   }
# 860 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator erase_after(const_iterator before_first, const_iterator last, difference_type n)
   {
      ((std::distance(++const_iterator(before_first), last) == difference_type(n)) ? static_cast<void> (0) : __assert_fail ("std::distance(++const_iterator(before_first), last) == difference_type(n)", "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp", 862, __PRETTY_FUNCTION__));
      if(safemode_or_autounlink){
         return this->erase_after(before_first, last);
      }
      else{
         node_ptr bfp = before_first.pointed_node();
         node_ptr lp = last.pointed_node();
         if(cache_last){
            if((lp == this->get_end_node())){
               this->set_last_node(bfp);
            }
         }
         node_algorithms::unlink_after(bfp, lp);
         if(constant_time_size){
            this->priv_size_traits().set_size(this->priv_size_traits().get_size() - n);
         }
         return last.unconst();
      }
   }
# 894 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator erase(const_iterator i)
   { return this->erase_after(this->previous(i)); }
# 911 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator erase(const_iterator first, const_iterator last)
   { return this->erase_after(this->previous(first), last); }
# 928 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator erase(const_iterator first, const_iterator last, difference_type n)
   { return this->erase_after(this->previous(first), last, n); }
# 945 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   iterator erase_after_and_dispose(const_iterator prev, Disposer disposer)
   {
      const_iterator it(prev);
      ++it;
      node_ptr to_erase(it.pointed_node());
      ++it;
      node_ptr prev_n(prev.pointed_node());
      node_algorithms::unlink_after(prev_n);
      if(cache_last && (to_erase == this->get_last_node())){
         this->set_last_node(prev_n);
      }
      if(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(get_real_value_traits().to_value_ptr(to_erase));
      this->priv_size_traits().decrement();
      return it.unconst();
   }



   template<class Disposer>
   static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))) == 0 ? false : true) >)> boost_static_assert_typedef_969;
      const_iterator it(prev);
      ++it;
      node_ptr to_erase(it.pointed_node());
      ++it;
      node_ptr prev_n(prev.pointed_node());
      node_algorithms::unlink_after(prev_n);
      if(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(real_value_traits::to_value_ptr(to_erase));
      return it.unconst();
   }

   static iterator s_erase_after(const_iterator prev)
   { return s_erase_after_and_dispose(prev, detail::null_disposer()); }
# 1001 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   iterator erase_after_and_dispose(const_iterator before_first, const_iterator last, Disposer disposer)
   {
      node_ptr bfp(before_first.pointed_node()), lp(last.pointed_node());
      node_ptr fp(node_traits::get_next(bfp));
      node_algorithms::unlink_after(bfp, lp);
      while(fp != lp){
         node_ptr to_erase(fp);
         fp = node_traits::get_next(fp);
         if(safemode_or_autounlink)
            node_algorithms::init(to_erase);
         disposer(get_real_value_traits().to_value_ptr(to_erase));
         this->priv_size_traits().decrement();
      }
      if(cache_last && (node_traits::get_next(bfp) == this->get_end_node())){
         this->set_last_node(bfp);
      }
      return last.unconst();
   }
# 1036 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer)
   { return this->erase_after_and_dispose(this->previous(i), disposer); }


   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer)
   { return this->erase_and_dispose(const_iterator(i), disposer); }
# 1063 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   iterator erase_and_dispose(const_iterator first, const_iterator last, Disposer disposer)
   { return this->erase_after_and_dispose(this->previous(first), last, disposer); }
# 1082 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Iterator>
   void assign(Iterator b, Iterator e)
   {
      this->clear();
      this->insert_after(this->cbefore_begin(), b, e);
   }
# 1105 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Iterator, class Disposer>
   void dispose_and_assign(Disposer disposer, Iterator b, Iterator e)
   {
      this->clear_and_dispose(disposer);
      this->insert_after(this->cbefore_begin(), b, e, disposer);
   }
# 1133 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice_after(const_iterator prev, slist_impl &x, const_iterator *last = 0)
   {
      if(x.empty()){
         if(last) *last = prev;
      }
      else if(linear && this->empty()){
         this->swap(x);
         if(last) *last = this->previous(this->cend());
      }
      else{
         const_iterator last_x(x.previous(x.end()));
         node_ptr prev_n(prev.pointed_node());
         node_ptr last_x_n(last_x.pointed_node());
         if(cache_last){
            x.set_last_node(x.get_root_node());
            if(node_traits::get_next(prev_n) == this->get_end_node()){
               this->set_last_node(last_x_n);
            }
         }
         node_algorithms::transfer_after( prev_n, x.before_begin().pointed_node(), last_x_n);
         this->priv_size_traits().set_size(this->priv_size_traits().get_size() + x.priv_size_traits().get_size());
         x.priv_size_traits().set_size(size_type(0));
         if(last) *last = last_x;
      }
   }
# 1172 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator prev_ele)
   {
      const_iterator elem = prev_ele;
      this->splice_after(prev_pos, x, prev_ele, ++elem, 1);
   }
# 1193 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_first, const_iterator before_last)
   {
      if(constant_time_size)
         this->splice_after(prev_pos, x, before_first, before_last, std::distance(before_first, before_last));
      else
         this->priv_splice_after
            (prev_pos.pointed_node(), x, before_first.pointed_node(), before_last.pointed_node());
   }
# 1216 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_first, const_iterator before_last, difference_type n)
   {
      if(n){
         ((std::distance(before_first, before_last) == n) ? static_cast<void> (0) : __assert_fail ("std::distance(before_first, before_last) == n", "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp", 1219, __PRETTY_FUNCTION__));
         this->priv_splice_after
            (prev_pos.pointed_node(), x, before_first.pointed_node(), before_last.pointed_node());
         if(constant_time_size){
            this->priv_size_traits().set_size(this->priv_size_traits().get_size() + n);
            x.priv_size_traits().set_size(x.priv_size_traits().get_size() - n);
         }
      }
   }
# 1250 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice(const_iterator it, slist_impl &x, const_iterator *last = 0)
   { this->splice_after(this->previous(it), x, last); }
# 1267 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice(const_iterator pos, slist_impl &x, const_iterator elem)
   { return this->splice_after(this->previous(pos), x, x.previous(elem)); }
# 1287 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last)
   { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last)); }
# 1306 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void splice(const_iterator pos, slist_impl &x, const_iterator first, const_iterator last, difference_type n)
   { return this->splice_after(this->previous(pos), x, x.previous(first), x.previous(last), n); }
# 1320 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Predicate>
   void sort(Predicate p)
   {
      if (node_traits::get_next(node_traits::get_next(this->get_root_node()))
         != this->get_root_node()) {

         slist_impl carry(this->priv_value_traits());
         detail::array_initializer<slist_impl, 64> counter(this->priv_value_traits());
         int fill = 0;
         const_iterator last_inserted;
         while(!this->empty()){
            last_inserted = this->cbegin();
            carry.splice_after(carry.cbefore_begin(), *this, this->cbefore_begin());
            int i = 0;
            while(i < fill && !counter[i].empty()) {
               carry.swap(counter[i]);
               carry.merge(counter[i++], p, &last_inserted);
            }
            ((counter[i].empty()) ? static_cast<void> (0) : __assert_fail ("counter[i].empty()", "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp", 1338, __PRETTY_FUNCTION__));
            const_iterator last_element(carry.previous(last_inserted, carry.end()));

            if(constant_time_size){
               counter[i].splice_after( counter[i].cbefore_begin(), carry
                                    , carry.cbefore_begin(), last_element
                                    , carry.size());
            }
            else{
               counter[i].splice_after( counter[i].cbefore_begin(), carry
                                    , carry.cbefore_begin(), last_element);
            }
            if(i == fill)
               ++fill;
         }

         for (int i = 1; i < fill; ++i)
            counter[i].merge(counter[i-1], p, &last_inserted);
         --fill;
         const_iterator last_element(counter[fill].previous(last_inserted, counter[fill].end()));
         if(constant_time_size){
            this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin()
                              , last_element, counter[fill].size());
         }
         else{
            this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin()
                              , last_element);
         }
      }
   }
# 1385 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void sort()
   { this->sort(std::less<value_type>()); }
# 1407 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Predicate>
   void merge(slist_impl& x, Predicate p, const_iterator *last = 0)
   {
      const_iterator e(this->cend()), ex(x.cend()), bb(this->cbefore_begin()),
                     bb_next;
      if(last) *last = e.unconst();
      while(!x.empty()){
         const_iterator ibx_next(x.cbefore_begin()), ibx(ibx_next++);
         while (++(bb_next = bb) != e && !p(*ibx_next, *bb_next)){
            bb = bb_next;
         }
         if(bb_next == e){

            this->splice_after(bb, x, last);
            break;
         }
         else{
            size_type n(0);
            do{
               ibx = ibx_next; ++n;
            } while(++(ibx_next = ibx) != ex && p(*ibx_next, *bb_next));
            this->splice_after(bb, x, x.before_begin(), ibx, n);
            if(last) *last = ibx;
         }
      }
   }
# 1445 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void merge(slist_impl& x)
   { this->merge(x, std::less<value_type>()); }
# 1455 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void reverse()
   {
      if(cache_last && !this->empty()){
         this->set_last_node(node_traits::get_next(this->get_root_node()));
      }
      this->priv_reverse(detail::bool_<linear>());
   }
# 1473 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void remove(const_reference value)
   { this->remove_if(detail::equal_to_value<const_reference>(value)); }
# 1487 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   void remove_and_dispose(const_reference value, Disposer disposer)
   { this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer); }
# 1500 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Pred>
   void remove_if(Pred pred)
   { this->remove_and_dispose_if(pred, detail::null_disposer()); }
# 1516 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Pred, class Disposer>
   void remove_and_dispose_if(Pred pred, Disposer disposer)
   {
      const_iterator bcur(this->before_begin()), cur(this->begin()), e(this->end());

      while(cur != e){
         if (pred(*cur)){
            cur = this->erase_after_and_dispose(bcur, disposer);
         }
         else{
            bcur = cur;
            ++cur;
         }
      }
      if(cache_last){
         this->set_last_node(bcur.pointed_node());
      }
   }
# 1544 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void unique()
   { this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer()); }
# 1557 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class BinaryPredicate>
   void unique(BinaryPredicate pred)
   { this->unique_and_dispose(pred, detail::null_disposer()); }
# 1573 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class Disposer>
   void unique_and_dispose(Disposer disposer)
   { this->unique(std::equal_to<value_type>(), disposer); }
# 1589 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   template<class BinaryPredicate, class Disposer>
   void unique_and_dispose(BinaryPredicate pred, Disposer disposer)
   {
      const_iterator end_n(this->cend());
      const_iterator bcur(this->cbegin());
      if(bcur != end_n){
         const_iterator cur(bcur);
         ++cur;
         while(cur != end_n) {
            if (pred(*bcur, *cur)){
               cur = this->erase_after_and_dispose(bcur, disposer);
            }
            else{
               bcur = cur;
               ++cur;
            }
         }
         if(cache_last){
            this->set_last_node(bcur.pointed_node());
         }
      }
   }
# 1623 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   static iterator s_iterator_to(reference value)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!stateful_value_traits)) == 0 ? false : true) >)> boost_static_assert_typedef_1625;

      return iterator (value_traits::to_node_ptr(value), 0);
   }
# 1641 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   static const_iterator s_iterator_to(const_reference value)
   {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((!stateful_value_traits)) == 0 ? false : true) >)> boost_static_assert_typedef_1643;

      return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), 0);
   }
# 1657 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator iterator_to(reference value)
   {

      return iterator (value_traits::to_node_ptr(value), this);
   }
# 1672 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   const_iterator iterator_to(const_reference value) const
   {

      return const_iterator (value_traits::to_node_ptr(const_cast<reference> (value)), this);
   }
# 1686 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator previous(iterator i)
   { return this->previous(this->cbefore_begin(), i); }
# 1697 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   const_iterator previous(const_iterator i) const
   { return this->previous(this->cbefore_begin(), i); }
# 1709 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   iterator previous(const_iterator prev_from, iterator i)
   { return this->previous(prev_from, const_iterator(i)).unconst(); }
# 1721 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   const_iterator previous(const_iterator prev_from, const_iterator i) const
   {
      if(cache_last && (i.pointed_node() == this->get_end_node())){
         return const_iterator(uncast(this->get_last_node()), this);
      }
      return const_iterator
         (node_algorithms::get_previous_node
            (prev_from.pointed_node(), i.pointed_node()), this);
   }
# 1746 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void incorporate_after(const_iterator prev_from, const node_ptr & first, const node_ptr & before_last)
   {
      if(constant_time_size)
         this->incorporate_after(prev_from, first, before_last, std::distance(first, before_last)+1);
      else
         this->priv_incorporate_after
            (prev_from.pointed_node(), first, before_last);
   }
# 1769 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp"
   void incorporate_after(const_iterator prev_pos, const node_ptr & first, const node_ptr & before_last, difference_type n)
   {
      if(n){
         ((std::distance(iterator(first, this), iterator(before_last, this))+1 == n) ? static_cast<void> (0) : __assert_fail ("std::distance(iterator(first, this), iterator(before_last, this))+1 == n", "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp", 1772, __PRETTY_FUNCTION__));
         this->priv_incorporate_after(prev_pos.pointed_node(), first, before_last);
         if(constant_time_size){
            this->priv_size_traits().set_size(this->priv_size_traits().get_size() + n);
         }
      }
   }

   private:
   void priv_splice_after(const node_ptr & prev_pos_n, slist_impl &x, const node_ptr & before_first_n, const node_ptr & before_last_n)
   {
      if (before_first_n != before_last_n && prev_pos_n != before_first_n && prev_pos_n != before_last_n)
      {
         if(cache_last){
            if(node_traits::get_next(prev_pos_n) == this->get_end_node()){
               this->set_last_node(before_last_n);
            }
            if(node_traits::get_next(before_last_n) == x.get_end_node()){
               x.set_last_node(before_first_n);
            }
         }
         node_algorithms::transfer_after(prev_pos_n, before_first_n, before_last_n);
      }
   }

   void priv_incorporate_after(const node_ptr & prev_pos_n, const node_ptr & first_n, const node_ptr & before_last_n)
   {
      if(cache_last){
         if(node_traits::get_next(prev_pos_n) == this->get_end_node()){
            this->set_last_node(before_last_n);
         }
      }
      node_algorithms::incorporate_after(prev_pos_n, first_n, before_last_n);
   }

   void priv_reverse(detail::bool_<false>)
   { node_algorithms::reverse(this->get_root_node()); }

   void priv_reverse(detail::bool_<true>)
   {
      node_ptr new_first = node_algorithms::reverse
         (node_traits::get_next(this->get_root_node()));
      node_traits::set_next(this->get_root_node(), new_first);
   }

   void priv_shift_backwards(size_type n, detail::bool_<false>)
   {
      node_ptr last = node_algorithms::move_forward(this->get_root_node(), (std::size_t)n);
      if(cache_last && last){
         this->set_last_node(last);
      }
   }

   void priv_shift_backwards(size_type n, detail::bool_<true>)
   {
      std::pair<node_ptr, node_ptr> ret(
         node_algorithms::move_first_n_forward
            (node_traits::get_next(this->get_root_node()), (std::size_t)n));
      if(ret.first){
         node_traits::set_next(this->get_root_node(), ret.first);
         if(cache_last){
            this->set_last_node(ret.second);
         }
      }
   }

   void priv_shift_forward(size_type n, detail::bool_<false>)
   {
      node_ptr last = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
      if(cache_last && last){
         this->set_last_node(last);
      }
   }

   void priv_shift_forward(size_type n, detail::bool_<true>)
   {
      std::pair<node_ptr, node_ptr> ret(
         node_algorithms::move_first_n_backwards
         (node_traits::get_next(this->get_root_node()), (std::size_t)n));
      if(ret.first){
         node_traits::set_next(this->get_root_node(), ret.first);
         if(cache_last){
            this->set_last_node(ret.second);
         }
      }
   }

   static void priv_swap_cache_last(slist_impl *this_impl, slist_impl *other_impl)
   {
      bool other_was_empty = false;
      if(this_impl->empty()){

         if(other_impl->empty())
            return;

         slist_impl *tmp = this_impl;
         this_impl = other_impl;
         other_impl = tmp;
         other_was_empty = true;
      }
      else{
         other_was_empty = other_impl->empty();
      }


      node_ptr other_old_last(other_impl->get_last_node());
      node_ptr other_bfirst(other_impl->get_root_node());
      node_ptr this_bfirst(this_impl->get_root_node());
      node_ptr this_old_last(this_impl->get_last_node());


      node_algorithms::transfer_after(other_bfirst, this_bfirst, this_old_last);
      other_impl->set_last_node(this_old_last);

      if(other_was_empty){
         this_impl->set_last_node(this_bfirst);
      }
      else{

         node_algorithms::transfer_after(this_bfirst, this_old_last, other_old_last);
         this_impl->set_last_node(other_old_last);
      }
   }


   static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<false>)
   { node_algorithms::swap_nodes(this_node, other_node); }


   static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<true>)
   { node_algorithms::swap_trailing_nodes(this_node, other_node); }

   static slist_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
   {


      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!linear) == 0 ? false : true) >)> boost_static_assert_typedef_1908;
      root_plus_size *r = detail::parent_from_member<root_plus_size, node>
         ( boost::intrusive::detail::to_raw_pointer(end_iterator.pointed_node()), (&root_plus_size::root_));
      data_t *d = detail::parent_from_member<data_t, root_plus_size>
         ( r, &data_t::root_plus_size_);
      slist_impl *s = detail::parent_from_member<slist_impl, data_t>(d, &slist_impl::data_);
      return *s;
   }
};




template<class Config>

inline bool operator<



(const slist_impl<Config> &x, const slist_impl<Config> &y)

{ return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }




template<class Config>

bool operator==



(const slist_impl<Config> &x, const slist_impl<Config> &y)

{
   typedef slist_impl<Config> slist_type;
   typedef typename slist_type::const_iterator const_iterator;
   const bool C = slist_type::constant_time_size;
   if(C && x.size() != y.size()){
      return false;
   }
   const_iterator end1 = x.end();

   const_iterator i1 = x.begin();
   const_iterator i2 = y.begin();
   if(C){
      while (i1 != end1 && *i1 == *i2) {
         ++i1;
         ++i2;
      }
      return i1 == end1;
   }
   else{
      const_iterator end2 = y.end();
      while (i1 != end1 && i2 != end2 && *i1 == *i2) {
         ++i1;
         ++i2;
      }
      return i1 == end1 && i2 == end2;
   }
}




template<class Config>

inline bool operator!=



(const slist_impl<Config> &x, const slist_impl<Config> &y)

{ return !(x == y); }




template<class Config>

inline bool operator>



(const slist_impl<Config> &x, const slist_impl<Config> &y)

{ return y < x; }




template<class Config>

inline bool operator<=



(const slist_impl<Config> &x, const slist_impl<Config> &y)

{ return !(y < x); }




template<class Config>

inline bool operator>=



(const slist_impl<Config> &x, const slist_impl<Config> &y)

{ return !(x < y); }




template<class Config>

inline void swap



(slist_impl<Config> &x, slist_impl<Config> &y)

{ x.swap(y); }






template<class T, class O1 = none, class O2 = none, class O3 = none, class O4 = none, class O5 = none>

struct make_slist
{

   typedef typename pack_options
      < slist_defaults<T>,

         O1, O2, O3, O4, O5



      >::type packed_options;
   typedef typename detail::get_value_traits
      <T, typename packed_options::value_traits>::type value_traits;
   typedef slist_impl
      <
         slistopt
         < value_traits
         , typename packed_options::size_type
         , packed_options::constant_time_size
         , packed_options::linear
         , packed_options::cache_last
         >
      > implementation_defined;

   typedef implementation_defined type;
};





template<class T, class O1, class O2, class O3, class O4, class O5>



class slist
   : public make_slist<T,

         O1, O2, O3, O4, O5



      >::type
{
   typedef typename make_slist
      <T,

      O1, O2, O3, O4, O5



      >::type Base;
   typedef typename Base::real_value_traits real_value_traits;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((detail::is_same<typename real_value_traits::value_type, T>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_2096;
   private: slist(slist &); slist& operator=(slist &); public: operator ::boost::rv<slist>&() { return *static_cast< ::boost::rv<slist>* >(this); } operator const ::boost::rv<slist>&() const { return *static_cast<const ::boost::rv<slist>* >(this); } private:

   public:
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;

   slist(const value_traits &v_traits = value_traits())
      : Base(v_traits)
   {}

   template<class Iterator>
   slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
      : Base(b, e, v_traits)
   {}

   slist(::boost::rv< slist >& x)
      : Base(::boost::move(static_cast<Base&>(x)))
   {}

   slist& operator=(::boost::rv< slist >& x)
   { this->Base::operator=(::boost::move(static_cast<Base&>(x))); return *this; }

   static slist &container_from_end_iterator(iterator end_iterator)
   { return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); }

   static const slist &container_from_end_iterator(const_iterator end_iterator)
   { return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator)); }
};



}
}

# 1 "/opt/sevenflow/boost/include/boost/intrusive/detail/config_end.hpp" 1
# 2133 "/opt/sevenflow/boost/include/boost/intrusive/slist.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 2




namespace boost {
namespace container {
namespace container_detail {

template<class VoidPointer>
class basic_multiallocation_chain
{
   private:
   typedef bi::slist_base_hook<bi::void_pointer<VoidPointer>
                        ,bi::link_mode<bi::normal_link>
                        > node;

   typedef typename boost::intrusive::pointer_traits
      <VoidPointer>::template rebind_pointer<char>::type char_ptr;
   typedef typename boost::intrusive::
      pointer_traits<char_ptr>::difference_type difference_type;

   typedef bi::slist< node
                    , bi::linear<true>
                    , bi::cache_last<true>
                    , bi::size_type<typename boost::make_unsigned<difference_type>::type>
                    > slist_impl_t;
   slist_impl_t slist_impl_;

   static node & to_node(VoidPointer p)
   { return *static_cast<node*>(static_cast<void*>(container_detail::to_raw_pointer(p))); }

   private: basic_multiallocation_chain(basic_multiallocation_chain &); basic_multiallocation_chain& operator=(basic_multiallocation_chain &); public: operator ::boost::rv<basic_multiallocation_chain>&() { return *static_cast< ::boost::rv<basic_multiallocation_chain>* >(this); } operator const ::boost::rv<basic_multiallocation_chain>&() const { return *static_cast<const ::boost::rv<basic_multiallocation_chain>* >(this); } private:

   public:


   typedef VoidPointer void_pointer;
   typedef typename slist_impl_t::iterator iterator;
   typedef typename slist_impl_t::size_type size_type;

   basic_multiallocation_chain()
      : slist_impl_()
   {}

   basic_multiallocation_chain(::boost::rv< basic_multiallocation_chain >& other)
      : slist_impl_()
   { slist_impl_.swap(other.slist_impl_); }

   basic_multiallocation_chain& operator=(::boost::rv< basic_multiallocation_chain >& other)
   {
      basic_multiallocation_chain tmp(boost::move(other));
      this->swap(tmp);
      return *this;
   }

   bool empty() const
   { return slist_impl_.empty(); }

   size_type size() const
   { return slist_impl_.size(); }

   iterator before_begin()
   { return slist_impl_.before_begin(); }

   iterator begin()
   { return slist_impl_.begin(); }

   iterator end()
   { return slist_impl_.end(); }

   iterator last()
   { return slist_impl_.last(); }

   void clear()
   { slist_impl_.clear(); }

   iterator insert_after(iterator it, void_pointer m)
   { return slist_impl_.insert_after(it, to_node(m)); }

   void push_front(void_pointer m)
   { return slist_impl_.push_front(to_node(m)); }

   void push_back(void_pointer m)
   { return slist_impl_.push_back(to_node(m)); }

   void pop_front()
   { return slist_impl_.pop_front(); }

   void *front()
   { return &*slist_impl_.begin(); }

   void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end)
   { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end); }

   void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
   { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end, n); }

   void splice_after(iterator after_this, basic_multiallocation_chain &x)
   { slist_impl_.splice_after(after_this, x.slist_impl_); }

   void incorporate_after(iterator after_this, void_pointer begin , iterator before_end)
   { slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end)); }

   void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
   { slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end), n); }

   void swap(basic_multiallocation_chain &x)
   { slist_impl_.swap(x.slist_impl_); }

   static iterator iterator_to(void_pointer p)
   { return slist_impl_t::s_iterator_to(to_node(p)); }

   std::pair<void_pointer, void_pointer> extract_data()
   {
      std::pair<void_pointer, void_pointer> ret
         (slist_impl_.begin().operator->()
         ,slist_impl_.last().operator->());
      slist_impl_.clear();
      return ret;
   }
};

template<class T>
struct cast_functor
{
   typedef typename container_detail::add_reference<T>::type result_type;
   template<class U>
   result_type operator()(U &ptr) const
   { return *static_cast<T*>(static_cast<void*>(&ptr)); }
};

template<class MultiallocationChain, class T>
class transform_multiallocation_chain
{
   private:
   private: transform_multiallocation_chain(transform_multiallocation_chain &); transform_multiallocation_chain& operator=(transform_multiallocation_chain &); public: operator ::boost::rv<transform_multiallocation_chain>&() { return *static_cast< ::boost::rv<transform_multiallocation_chain>* >(this); } operator const ::boost::rv<transform_multiallocation_chain>&() const { return *static_cast<const ::boost::rv<transform_multiallocation_chain>* >(this); } private:

   MultiallocationChain holder_;
   typedef typename MultiallocationChain::void_pointer void_pointer;
   typedef typename boost::intrusive::pointer_traits
      <void_pointer>::template rebind_pointer<T>::type pointer;

   static pointer cast(void_pointer p)
   {
      return pointer(static_cast<T*>(container_detail::to_raw_pointer(p)));
   }

   public:
   typedef transform_iterator
      < typename MultiallocationChain::iterator
      , container_detail::cast_functor <T> > iterator;
   typedef typename MultiallocationChain::size_type size_type;

   transform_multiallocation_chain()
      : holder_()
   {}

   transform_multiallocation_chain(::boost::rv< transform_multiallocation_chain >& other)
      : holder_()
   { this->swap(other); }

   transform_multiallocation_chain(::boost::rv< MultiallocationChain >& other)
      : holder_(boost::move(other))
   {}

   transform_multiallocation_chain& operator=(::boost::rv< transform_multiallocation_chain >& other)
   {
      transform_multiallocation_chain tmp(boost::move(other));
      this->swap(tmp);
      return *this;
   }

   void push_front(pointer mem)
   { holder_.push_front(mem); }

   void swap(transform_multiallocation_chain &other_chain)
   { holder_.swap(other_chain.holder_); }

   void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, size_type n)
   { holder_.splice_after(after_this.base(), x.holder_, before_begin.base(), before_end.base(), n); }

   void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, size_type n)
   { holder_.incorporate_after(after_this.base(), begin, before_end, n); }

   void pop_front()
   { holder_.pop_front(); }

   pointer front()
   { return cast(holder_.front()); }

   bool empty() const
   { return holder_.empty(); }

   iterator before_begin()
   { return iterator(holder_.before_begin()); }

   iterator begin()
   { return iterator(holder_.begin()); }

   iterator end()
   { return iterator(holder_.end()); }

   iterator last()
   { return iterator(holder_.last()); }

   size_type size() const
   { return holder_.size(); }

   void clear()
   { holder_.clear(); }

   iterator insert_after(iterator it, pointer m)
   { return iterator(holder_.insert_after(it.base(), m)); }

   static iterator iterator_to(pointer p)
   { return iterator(MultiallocationChain::iterator_to(p)); }

   std::pair<void_pointer, void_pointer> extract_data()
   { return holder_.extract_data(); }

   MultiallocationChain extract_multiallocation_chain()
   {
      return MultiallocationChain(boost::move(holder_));
   }
};

}}}





# 1 "/opt/sevenflow/boost/include/boost/container/detail/config_end.hpp" 1
# 253 "/opt/sevenflow/boost/include/boost/container/detail/multiallocation_chain.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/utility/addressof.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/utility/addressof.hpp"
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 "/opt/sevenflow/boost/include/boost/utility/addressof.hpp"
}
# 22 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/lock_options.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/sync/lock_options.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/sync/lock_options.hpp" 2





namespace boost {

namespace posix_time
{ class ptime; }

namespace interprocess {


struct defer_lock_type{};

struct try_to_lock_type {};

struct accept_ownership_type{};



static const defer_lock_type defer_lock = defer_lock_type();



static const try_to_lock_type try_to_lock = try_to_lock_type();



static const accept_ownership_type accept_ownership = accept_ownership_type();

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 54 "/opt/sevenflow/boost/include/boost/interprocess/sync/lock_options.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/posix_time_types_wrk.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/interprocess/detail/posix_time_types_wrk.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 1
# 10 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_clock.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/time_clock.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp"
# 1 "/usr/include/c++/4.8.2/ctime" 1 3
# 39 "/usr/include/c++/4.8.2/ctime" 3
       
# 40 "/usr/include/c++/4.8.2/ctime" 3
# 58 "/usr/include/c++/4.8.2/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 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/throw_exception.hpp" 1



       
# 5 "/opt/sevenflow/boost/include/boost/throw_exception.hpp" 3
# 29 "/opt/sevenflow/boost/include/boost/throw_exception.hpp" 3
# 1 "/opt/sevenflow/boost/include/boost/exception/detail/attribute_noreturn.hpp" 1 3
# 30 "/opt/sevenflow/boost/include/boost/throw_exception.hpp" 2 3
# 43 "/opt/sevenflow/boost/include/boost/throw_exception.hpp" 3
# 1 "/opt/sevenflow/boost/include/boost/exception/exception.hpp" 1 3
# 9 "/opt/sevenflow/boost/include/boost/exception/exception.hpp" 3
       
# 10 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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)));
        }
    }

}
# 21 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp" 1
# 11 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp"
# 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
# 39 "/usr/include/c++/4.8.2/cstdlib" 3
       
# 40 "/usr/include/c++/4.8.2/cstdlib" 3
# 12 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp" 2
# 31 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/locale_config.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp" 2
# 54 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp"
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 55 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp" 2
# 157 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/auto_link.hpp" 1
# 158 "/opt/sevenflow/boost/include/boost/date_time/compiler_config.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp" 2
# 31 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp"
# 1 "/usr/include/sys/time.h" 1 3 4
# 28 "/usr/include/sys/time.h" 3 4
# 1 "/usr/include/bits/time.h" 1 3 4
# 29 "/usr/include/sys/time.h" 2 3 4
# 38 "/usr/include/sys/time.h" 3 4
extern "C" {
# 56 "/usr/include/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };

typedef struct timezone *__restrict __timezone_ptr_t;
# 72 "/usr/include/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/sys/time.h" 3 4
}
# 32 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp" 2






namespace boost {
namespace date_time {
# 52 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp"
  struct c_time {
    public:


      inline
      static std::tm* localtime(const std::time_t* t, std::tm* result)
      {
# 67 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp"
        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 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp"
        result = gmtime_r(t, result);

        if (!result)
          boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
        return result;
      }
# 120 "/opt/sevenflow/boost/include/boost/date_time/c_time.hpp"
  };
}}
# 17 "/opt/sevenflow/boost/include/boost/date_time/time_clock.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/shared_ptr.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/shared_ptr.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/no_tr1/memory.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/checked_delete.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/checked_delete.hpp"
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 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/bad_weak_ptr.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/smart_ptr/bad_weak_ptr.hpp"
namespace boost
{
# 39 "/opt/sevenflow/boost/include/boost/smart_ptr/bad_weak_ptr.hpp"
class bad_weak_ptr: public std::exception
{
public:

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





}
# 29 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_has_sync.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp"
# 1 "/opt/sevenflow/boost/include/boost/detail/sp_typeinfo.hpp" 1
# 111 "/opt/sevenflow/boost/include/boost/detail/sp_typeinfo.hpp"
namespace boost
{

namespace detail
{







typedef std::type_info sp_typeinfo;



}

}
# 28 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 2

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;

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

}

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 39 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2

namespace boost
{
# 50 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp"
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;
    }
# 113 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp"
};
# 122 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp"
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;
    }
# 183 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_counted_impl.hpp"
};

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





}

}
# 31 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
namespace boost
{

namespace detail
{
# 53 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
struct sp_nothrow_tag {};

template< class D > struct sp_inplace_tag
{
};

class weak_count;

class shared_count
{
private:

    sp_counted_base * pi_;





    friend class weak_count;

public:

    shared_count(): pi_(0)



    {
    }

    template<class Y> explicit shared_count( Y * p ): pi_( 0 )



    {


        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
# 110 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    }




    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;
        }
# 147 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    }



    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;
        }
# 179 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    }



    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;
        }
# 227 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    }



    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;
        }
# 275 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    }







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



    {
# 298 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
        r.release();
    }



    ~shared_count()
    {
        if( pi_ != 0 ) pi_->release();



    }

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



    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }
# 331 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    explicit shared_count(weak_count const & r);
    shared_count( weak_count const & r, sp_nothrow_tag );

    shared_count & operator= (shared_count const & r)
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if( tmp != 0 ) tmp->add_ref_copy();
            if( pi_ != 0 ) pi_->release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(shared_count & r)
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const
    {
        return use_count() == 1;
    }

    bool empty() const
    {
        return pi_ == 0;
    }

    friend inline bool operator==(shared_count const & a, shared_count const & b)
    {
        return a.pi_ == b.pi_;
    }

    friend inline bool operator<(shared_count const & a, shared_count const & b)
    {
        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
    }

    void * get_deleter( sp_typeinfo const & ti ) const
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }
};


class weak_count
{
private:

    sp_counted_base * pi_;





    friend class shared_count;

public:

    weak_count(): pi_(0)



    {
    }

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



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }

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



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }
# 438 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/shared_count.hpp"
    ~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 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_convertible.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/sp_convertible.hpp"
namespace boost
{

namespace detail
{

template< class Y, class T > struct sp_convertible
{
    typedef char (&yes) [1];
    typedef char (&no) [2];

    static yes f( T* );
    static no f( ... );

    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
};

struct sp_empty
{
};

template< bool > struct sp_enable_if_convertible_impl;

template<> struct sp_enable_if_convertible_impl<true>
{
    typedef sp_empty type;
};

template<> struct sp_enable_if_convertible_impl<false>
{
};

template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};

}

}
# 35 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock.hpp" 1
# 41 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_sync.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_sync.hpp"
# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/yield_k.hpp" 1
# 91 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/yield_k.hpp"
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 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_sync.hpp" 2





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 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 27 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2

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

}
}
# 38 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/memory_order.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/memory_order.hpp"
namespace boost
{
# 41 "/opt/sevenflow/boost/include/boost/memory_order.hpp"
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
};

}
# 39 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2





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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 45 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2
# 54 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
namespace boost
{

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

namespace detail
{

struct static_cast_tag {};
struct const_cast_tag {};
struct dynamic_cast_tag {};
struct polymorphic_cast_tag {};

template<class T> struct shared_ptr_traits
{
    typedef T & reference;
};

template<> struct shared_ptr_traits<void>
{
    typedef void reference;
};



template<> struct shared_ptr_traits<void const>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void volatile>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void const volatile>
{
    typedef void reference;
};





template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}
# 132 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
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;
};



}
# 164 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
template<class T> class shared_ptr
{
private:


    typedef shared_ptr<T> this_type;

public:

    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;

    shared_ptr(): px(0), pn()
    {
    }

    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn( p )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }







    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }



    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }
# 218 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
    {

        px = r.px;
    }

    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    : px( r.px ), pn( r.pn )
    {
    }


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

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

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

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            pn = boost::detail::shared_count();
        }
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }



    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
        Y * tmp = r.get();
        pn = boost::detail::shared_count(r);
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }



    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
    {
        typename Ap::element_type * tmp = r.get();
        pn = boost::detail::shared_count( r );
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }
# 309 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
    shared_ptr & operator=( shared_ptr const & r )
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r)
    {
        this_type(r).swap(*this);
        return *this;
    }





    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Ap>
    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
    {
        this_type( r ).swap( *this );
        return *this;
    }
# 390 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
    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", "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp", 397, __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, T * p )
    {
        this_type( r, p ).swap( *this );
    }

    reference operator* () const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp", 418, __PRETTY_FUNCTION__));
        return *px;
    }

    T * operator-> () const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp", 424, __PRETTY_FUNCTION__));
        return px;
    }

    T * get() const
    {
        return px;
    }


# 1 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/operator_bool.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/smart_ptr/detail/operator_bool.hpp"
    typedef T * this_type::*unspecified_bool_type;

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




    bool operator! () const
    {
        return px == 0;
    }
# 435 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp" 2

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

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

    void swap(shared_ptr<T> & other)
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
    {
        return pn < rhs.pn;
    }

    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
    {
        return pn.get_deleter( ti );
    }

    bool _internal_equiv( shared_ptr const & r ) const
    {
        return px == r.px && pn == r.pn;
    }






private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;




    T * px;
    boost::detail::shared_count pn;

};

template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() != b.get();
}
# 511 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.owner_before( b );
}

template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
{
    a.swap(b);
}

template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::const_cast_tag());
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}



template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
{
    ((dynamic_cast<T *>(r.get()) == r.get()) ? static_cast<void> (0) : __assert_fail ("dynamic_cast<T *>(r.get()) == r.get()", "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp", 555, __PRETTY_FUNCTION__));
    return shared_static_cast<T>(r);
}



template<class T> inline T * get_pointer(shared_ptr<T> const & p)
{
    return p.get();
}
# 588 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
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;
}
# 618 "/opt/sevenflow/boost/include/boost/smart_ptr/shared_ptr.hpp"
template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
{
    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
}







template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * )
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
    atomic_store( p, r );
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r;
}

template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
{
    return atomic_exchange( p, r );
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
{
    return atomic_compare_exchange( p, v, w );
}





template< class T > struct hash;

template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p )
{
    return boost::hash< T* >()( p.get() );
}

}
# 18 "/opt/sevenflow/boost/include/boost/shared_ptr.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/date_time/time_clock.hpp" 2

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

  };


} }
# 11 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/microsec_time_clock.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/date_time/microsec_time_clock.hpp"
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/date_time/microsec_time_clock.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/date_time/filetime_functions.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/date_time/microsec_time_clock.hpp" 2



namespace boost {
namespace date_time {
# 38 "/opt/sevenflow/boost/include/boost/date_time/microsec_time_clock.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/microsec_time_clock.hpp"
      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);
    }
  };


} }
# 12 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/ptime.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/posix_time/ptime.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_system.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp"
# 1 "/usr/include/c++/4.8.2/cstdlib" 1 3
# 39 "/usr/include/c++/4.8.2/cstdlib" 3
       
# 40 "/usr/include/c++/4.8.2/cstdlib" 3
# 13 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/limits.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/config/no_tr1/cmath.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/config/no_tr1/cmath.hpp"
# 1 "/usr/include/c++/4.8.2/cmath" 1 3
# 39 "/usr/include/c++/4.8.2/cmath" 3
       
# 40 "/usr/include/c++/4.8.2/cmath" 3




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



# 1 "/usr/include/bits/huge_val.h" 1 3 4
# 34 "/usr/include/math.h" 2 3 4

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


# 1 "/usr/include/bits/inf.h" 1 3 4
# 40 "/usr/include/math.h" 2 3 4


# 1 "/usr/include/bits/nan.h" 1 3 4
# 43 "/usr/include/math.h" 2 3 4



# 1 "/usr/include/bits/mathdef.h" 1 3 4
# 28 "/usr/include/bits/mathdef.h" 3 4
typedef float float_t;
typedef double double_t;
# 47 "/usr/include/math.h" 2 3 4
# 70 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/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/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/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
# 133 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 52 "/usr/include/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 ();
# 134 "/usr/include/math.h" 2 3 4
# 149 "/usr/include/math.h" 3 4
extern int signgam;
# 190 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

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




extern _LIB_VERSION_TYPE _LIB_VERSION;
# 311 "/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 ();
# 475 "/usr/include/math.h" 3 4
}
# 45 "/usr/include/c++/4.8.2/cmath" 2 3
# 75 "/usr/include/c++/4.8.2/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.2/cmath" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 805 "/usr/include/c++/4.8.2/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 "/opt/sevenflow/boost/include/boost/config/no_tr1/cmath.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp"
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/operators.hpp" 1
# 86 "/opt/sevenflow/boost/include/boost/operators.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/iterator.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 19 "/opt/sevenflow/boost/include/boost/iterator.hpp" 2


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

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

  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 "/opt/sevenflow/boost/include/boost/operators.hpp" 2
# 97 "/opt/sevenflow/boost/include/boost/operators.hpp"
namespace boost {
namespace detail {

template <typename T> class empty_base {






};

}
}
# 120 "/opt/sevenflow/boost/include/boost/operators.hpp"
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 "/opt/sevenflow/boost/include/boost/operators.hpp"
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 "/opt/sevenflow/boost/include/boost/operators.hpp"
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 "/opt/sevenflow/boost/include/boost/operators.hpp"
namespace boost {


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




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

}
# 831 "/opt/sevenflow/boost/include/boost/operators.hpp"
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 "/opt/sevenflow/boost/include/boost/operators.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_defs.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/date_time/time_defs.hpp"
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};


} }
# 15 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/special_defs.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/special_defs.hpp"
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};


} }
# 16 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp" 2


namespace boost {
namespace date_time {
# 32 "/opt/sevenflow/boost/include/boost/date_time/time_duration.hpp"
  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::traits_type traits_type;
    explicit subsecond_duration(boost::int64_t ss) :
      base_duration(0,0,0,ss*traits_type::res_adjust()/frac_of_second)
    {}
  };



} }
# 17 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_resolution_traits.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/time_resolution_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/date_time/time_resolution_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/date_time/int_adapter.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/date_time/int_adapter.hpp"
namespace boost {
namespace date_time {
# 39 "/opt/sevenflow/boost/include/boost/date_time/int_adapter.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/int_adapter.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/time_resolution_traits.hpp" 2


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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/date.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/date.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/year_month_day.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/year_month_day.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/date.hpp" 2


namespace boost {
namespace date_time {
# 52 "/opt/sevenflow/boost/include/boost/date_time/date.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/period.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
namespace boost {
namespace date_time {
# 50 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/period.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp"
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_weekday.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_weekday.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/constrained_value.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/date_time/constrained_value.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_base_of.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/is_base_of.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_base_and_derived.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/type_traits/is_base_and_derived.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/type_traits/is_base_and_derived.hpp" 2

namespace boost {

namespace detail {
# 222 "/opt/sevenflow/boost/include/boost/type_traits/is_base_and_derived.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 253 "/opt/sevenflow/boost/include/boost/type_traits/is_base_and_derived.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_base_of.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_base_of.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/type_traits/is_base_of.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/date_time/constrained_value.hpp" 2

namespace boost {


namespace CV {

  enum violation_enum {min_violation, max_violation};
# 41 "/opt/sevenflow/boost/include/boost/date_time/constrained_value.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_weekday.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/date_defs.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/date_defs.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_weekday.hpp" 2




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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_day_of_year.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_day_of_year.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian_calendar.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/gregorian_calendar.hpp"
namespace boost {
namespace date_time {
# 27 "/opt/sevenflow/boost/include/boost/date_time/gregorian_calendar.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian_calendar.ipp" 1
# 14 "/opt/sevenflow/boost/include/boost/date_time/gregorian_calendar.ipp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian_calendar.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_ymd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_day.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_day.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_year.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_year.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_year.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_month.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_month.hpp"
# 1 "/usr/include/c++/4.8.2/map" 1 3
# 58 "/usr/include/c++/4.8.2/map" 3
       
# 59 "/usr/include/c++/4.8.2/map" 3

# 1 "/usr/include/c++/4.8.2/bits/stl_tree.h" 1 3
# 69 "/usr/include/c++/4.8.2/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 89 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/map" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_map.h" 1 3
# 66 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 94 "/usr/include/c++/4.8.2/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.2/bits/stl_map.h" 3
      map(const map& __x)
      : _M_t(__x._M_t) { }
# 223 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_map.h" 3
      map&
      operator=(const map& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 309 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_map.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 725 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 761 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 777 "/usr/include/c++/4.8.2/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.2/bits/stl_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 835 "/usr/include/c++/4.8.2/bits/stl_map.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }
# 847 "/usr/include/c++/4.8.2/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.2/bits/stl_map.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 877 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/map" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 1 3
# 64 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 92 "/usr/include/c++/4.8.2/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.2/bits/stl_multimap.h" 3
      multimap(const multimap& __x)
      : _M_t(__x._M_t) { }
# 218 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 303 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 533 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_multimap.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 630 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 670 "/usr/include/c++/4.8.2/bits/stl_multimap.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 686 "/usr/include/c++/4.8.2/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.2/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }
# 744 "/usr/include/c++/4.8.2/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.2/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }
# 783 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/map" 2 3
# 19 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_month.hpp" 2

# 1 "/usr/include/c++/4.8.2/cctype" 1 3
# 39 "/usr/include/c++/4.8.2/cctype" 3
       
# 40 "/usr/include/c++/4.8.2/cctype" 3
# 21 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_month.hpp" 2

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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_ymd.hpp" 2

namespace boost {
namespace gregorian {

  typedef date_time::year_month_day_base<greg_year,
                                         greg_month,
                                         greg_day> greg_year_month_day;



} }
# 17 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_calendar.hpp" 2


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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/date_duration.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/date_duration.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration.hpp" 2



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 "/opt/sevenflow/boost/include/boost/date_time/date_duration_types.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/date_duration_types.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration_types.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration_types.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_date.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_date.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_date.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration_types.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/date_time/adjust_functors.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/adjust_functors.hpp"
# 1 "/opt/sevenflow/boost/include/boost/date_time/wrapping_int.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/wrapping_int.hpp"
namespace boost {
namespace date_time {
# 30 "/opt/sevenflow/boost/include/boost/date_time/wrapping_int.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/adjust_functors.hpp" 2

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 "/opt/sevenflow/boost/include/boost/date_time/adjust_functors.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/greg_duration_types.hpp" 2



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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
# 1 "/usr/include/c++/4.8.2/sstream" 1 3
# 36 "/usr/include/c++/4.8.2/sstream" 3
       
# 37 "/usr/include/c++/4.8.2/sstream" 3




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

# 63 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/sstream.tcc" 1 3
# 37 "/usr/include/c++/4.8.2/bits/sstream.tcc" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/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.2/sstream" 2 3
# 18 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp" 2




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 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
   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 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/date_generators.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/date_clock_device.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/date_time/date_clock_device.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/date_iterator.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/date_time/date_iterator.hpp"
namespace boost {
namespace date_time {

  enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
# 32 "/opt/sevenflow/boost/include/boost/date_time/date_iterator.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/date_iterator.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/gregorian/gregorian_types.hpp" 2


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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp" 2



namespace boost {
namespace posix_time {
# 40 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp"
  typedef date_time::time_resolution_traits<
    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
                                            1000000, 6 > time_res_traits;
# 57 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp"
  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>;
  private:
    explicit time_duration(impl_type tick_count) :
      date_time::time_duration<time_duration, time_res_traits>(tick_count)
    {}
  };
# 154 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_config.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_system_split.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/date_time/time_system_split.hpp"
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 = 86400L * 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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_system_counted.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/date_time/time_system_counted.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/time_system_counted.hpp"
      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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_system.hpp" 2



namespace boost {
namespace posix_time {
# 32 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_system.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/ptime.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/date_time/time.hpp"
namespace boost {
namespace date_time {
# 45 "/opt/sevenflow/boost/include/boost/date_time/time.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/ptime.hpp" 2

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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/date_duration_operators.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/date_time/posix_time/date_duration_operators.hpp"
namespace boost {
namespace posix_time {
# 29 "/opt/sevenflow/boost/include/boost/date_time/posix_time/date_duration_operators.hpp"
  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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_duration.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_duration.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_duration.hpp"
} }
# 17 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/time_period.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/date_time/posix_time/time_period.hpp"
namespace boost {
namespace posix_time {




  typedef date_time::period<ptime, time_duration> time_period;


} }
# 19 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/time_iterator.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/date_time/time_iterator.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp"
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 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp"
      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 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp"
      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 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp"
      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 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp"
      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 "/opt/sevenflow/boost/include/boost/date_time/dst_rules.hpp"
    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 d)
      {
        return false;
      }

      static time_duration_type dst_offset()
      {
        return time_duration_type(0,0,0);
      }

    };


  } }
# 21 "/opt/sevenflow/boost/include/boost/date_time/posix_time/posix_time_types.hpp" 2

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;


} }
# 24 "/opt/sevenflow/boost/include/boost/interprocess/detail/posix_time_types_wrk.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/date_time/posix_time/conversion.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/posix_time/conversion.hpp"
# 1 "/usr/include/c++/4.8.2/cstring" 1 3
# 39 "/usr/include/c++/4.8.2/cstring" 3
       
# 40 "/usr/include/c++/4.8.2/cstring" 3
# 13 "/opt/sevenflow/boost/include/boost/date_time/posix_time/conversion.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/date_time/gregorian/conversion.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/date_time/gregorian/conversion.hpp"
# 1 "/usr/include/c++/4.8.2/cstring" 1 3
# 39 "/usr/include/c++/4.8.2/cstring" 3
       
# 40 "/usr/include/c++/4.8.2/cstring" 3
# 13 "/opt/sevenflow/boost/include/boost/date_time/gregorian/conversion.hpp" 2







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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/conversion.hpp" 2

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 "/opt/sevenflow/boost/include/boost/date_time/posix_time/conversion.hpp"
} }
# 25 "/opt/sevenflow/boost/include/boost/interprocess/detail/posix_time_types_wrk.hpp" 2

namespace boost {
namespace interprocess {

typedef boost::date_time::microsec_clock<boost::posix_time::ptime> microsec_clock;

}
}
# 32 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp" 2




namespace boost {
namespace interprocess {
# 50 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
template <class Mutex>
class scoped_lock
{

   private:
   typedef scoped_lock<Mutex> this_type;
   private: scoped_lock(scoped_lock &); scoped_lock& operator=(scoped_lock &); public: operator ::boost::rv<scoped_lock>&() { return *static_cast< ::boost::rv<scoped_lock>* >(this); } operator const ::boost::rv<scoped_lock>&() const { return *static_cast<const ::boost::rv<scoped_lock>* >(this); } private:
   typedef bool this_type::*unspecified_bool_type;

   public:

   typedef Mutex mutex_type;



   scoped_lock()
      : mp_mutex(0), m_locked(false)
   {}






   explicit scoped_lock(mutex_type& m)
      : mp_mutex(&m), m_locked(false)
   { mp_mutex->lock(); m_locked = true; }




   scoped_lock(mutex_type& m, defer_lock_type)
      : mp_mutex(&m), m_locked(false)
   {}




   scoped_lock(mutex_type& m, accept_ownership_type)
      : mp_mutex(&m), m_locked(true)
   {}
# 100 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   scoped_lock(mutex_type& m, try_to_lock_type)
      : mp_mutex(&m), m_locked(mp_mutex->try_lock())
   {}
# 112 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   scoped_lock(mutex_type& m, const boost::posix_time::ptime& abs_time)
      : mp_mutex(&m), m_locked(mp_mutex->timed_lock(abs_time))
   {}
# 126 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   scoped_lock(::boost::rv< scoped_lock >& scop)
      : mp_mutex(0), m_locked(scop.owns())
   { mp_mutex = scop.release(); }
# 142 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   template<class T>
   explicit scoped_lock(::boost::rv< upgradable_lock<T> >& upgr
      , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
      : mp_mutex(0), m_locked(false)
   {
      upgradable_lock<mutex_type> &u_lock = upgr;
      if(u_lock.owns()){
         u_lock.mutex()->unlock_upgradable_and_lock();
         m_locked = true;
      }
      mp_mutex = u_lock.release();
   }
# 170 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   template<class T>
   scoped_lock(::boost::rv< upgradable_lock<T> >& upgr, try_to_lock_type
         , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
      : mp_mutex(0), m_locked(false)
   {
      upgradable_lock<mutex_type> &u_lock = upgr;
      if(u_lock.owns()){
         if((m_locked = u_lock.mutex()->try_unlock_upgradable_and_lock()) == true){
            mp_mutex = u_lock.release();
         }
      }
      else{
         u_lock.release();
      }
   }
# 200 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   template<class T>
   scoped_lock(::boost::rv< upgradable_lock<T> >& upgr, boost::posix_time::ptime &abs_time
               , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
      : mp_mutex(0), m_locked(false)
   {
      upgradable_lock<mutex_type> &u_lock = upgr;
      if(u_lock.owns()){
         if((m_locked = u_lock.mutex()->timed_unlock_upgradable_and_lock(abs_time)) == true){
            mp_mutex = u_lock.release();
         }
      }
      else{
         u_lock.release();
      }
   }
# 231 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   template<class T>
   scoped_lock(::boost::rv< sharable_lock<T> >& shar, try_to_lock_type
      , typename ipcdetail::enable_if< ipcdetail::is_same<T, Mutex> >::type * = 0)
      : mp_mutex(0), m_locked(false)
   {
      sharable_lock<mutex_type> &s_lock = shar;
      if(s_lock.owns()){
         if((m_locked = s_lock.mutex()->try_unlock_sharable_and_lock()) == true){
            mp_mutex = s_lock.release();
         }
      }
      else{
         s_lock.release();
      }
   }



   ~scoped_lock()
   {
      try{ if(m_locked && mp_mutex) mp_mutex->unlock(); }
      catch(...){}
   }







   scoped_lock &operator=(::boost::rv< scoped_lock >& scop)
   {
      if(this->owns())
         this->unlock();
      m_locked = scop.owns();
      mp_mutex = scop.release();
      return *this;
   }






   void lock()
   {
      if(!mp_mutex || m_locked)
         throw lock_exception();
      mp_mutex->lock();
      m_locked = true;
   }
# 290 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   bool try_lock()
   {
      if(!mp_mutex || m_locked)
         throw lock_exception();
      m_locked = mp_mutex->try_lock();
      return m_locked;
   }
# 305 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp"
   bool timed_lock(const boost::posix_time::ptime& abs_time)
   {
      if(!mp_mutex || m_locked)
         throw lock_exception();
      m_locked = mp_mutex->timed_lock(abs_time);
      return m_locked;
   }






   void unlock()
   {
      if(!mp_mutex || !m_locked)
         throw lock_exception();
      mp_mutex->unlock();
      m_locked = false;
   }



   bool owns() const
   { return m_locked && mp_mutex; }



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



   mutex_type* mutex() const
   { return mp_mutex; }




   mutex_type* release()
   {
      mutex_type *mut = mp_mutex;
      mp_mutex = 0;
      m_locked = false;
      return mut;
   }



   void swap( scoped_lock<mutex_type> &other)
   {
      std::swap(mp_mutex, other.mp_mutex);
      std::swap(m_locked, other.m_locked);
   }


   private:
   mutex_type *mp_mutex;
   bool m_locked;

};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 371 "/opt/sevenflow/boost/include/boost/interprocess/sync/scoped_lock.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/math_functions.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/math_functions.hpp"
# 1 "/usr/include/c++/4.8.2/climits" 1 3
# 39 "/usr/include/c++/4.8.2/climits" 3
       
# 40 "/usr/include/c++/4.8.2/climits" 3

# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/climits" 2 3
# 20 "/opt/sevenflow/boost/include/boost/interprocess/detail/math_functions.hpp" 2


namespace boost {
namespace interprocess {
namespace ipcdetail {
# 34 "/opt/sevenflow/boost/include/boost/interprocess/detail/math_functions.hpp"
template <typename Integer>
inline Integer gcd(Integer A, Integer B)
{
   do
   {
      const Integer tmp(B);
      B = A % B;
      A = tmp;
   } while (B != 0);

   return A;
}







template <typename Integer>
inline Integer lcm(const Integer & A, const Integer & B)
{
   Integer ret = A;
   ret /= gcd(A, B);
   ret *= B;
   return ret;
}

template <typename Integer>
inline Integer log2_ceil(const Integer & A)
{
   Integer i = 0;
   Integer power_of_2 = 1;

   while(power_of_2 < A){
      power_of_2 <<= 1;
      ++i;
   }
   return i;
}

template <typename Integer>
inline Integer upper_power_of_2(const Integer & A)
{
   Integer power_of_2 = 1;

   while(power_of_2 < A){
      power_of_2 <<= 1;
   }
   return power_of_2;
}



inline std::size_t floor_log2 (std::size_t x)
{
   const std::size_t Bits = sizeof(std::size_t)*8;
   const bool Size_t_Bits_Power_2= !(Bits & (Bits-1));
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((((Size_t_Bits_Power_2)== true)) == 0 ? false : true) >)> boost_static_assert_typedef_92;

   std::size_t n = x;
   std::size_t log2 = 0;

   for(std::size_t shift = Bits >> 1; shift; shift >>= 1){
      std::size_t tmp = n >> shift;
      if (tmp)
         log2 += shift, n = tmp;
   }

   return log2;
}

}
}
}
# 26 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 2




namespace boost {
namespace interprocess {
namespace ipcdetail {



template<class MemoryAlgorithm>
class memory_algorithm_common
{
   public:
   typedef typename MemoryAlgorithm::void_pointer void_pointer;
   typedef typename MemoryAlgorithm::block_ctrl block_ctrl;
   typedef typename MemoryAlgorithm::multiallocation_chain multiallocation_chain;
   typedef memory_algorithm_common<MemoryAlgorithm> this_type;
   typedef typename MemoryAlgorithm::size_type size_type;

   static const size_type Alignment = MemoryAlgorithm::Alignment;
   static const size_type MinBlockUnits = MemoryAlgorithm::MinBlockUnits;
   static const size_type AllocatedCtrlBytes = MemoryAlgorithm::AllocatedCtrlBytes;
   static const size_type AllocatedCtrlUnits = MemoryAlgorithm::AllocatedCtrlUnits;
   static const size_type BlockCtrlBytes = MemoryAlgorithm::BlockCtrlBytes;
   static const size_type BlockCtrlUnits = MemoryAlgorithm::BlockCtrlUnits;
   static const size_type UsableByPreviousChunk = MemoryAlgorithm::UsableByPreviousChunk;

   static void assert_alignment(const void *ptr)
   { assert_alignment((std::size_t)ptr); }

   static void assert_alignment(size_type uint_ptr)
   {
      (void)uint_ptr;
      ((uint_ptr % Alignment == 0) ? static_cast<void> (0) : __assert_fail ("uint_ptr % Alignment == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 69, __PRETTY_FUNCTION__));
   }

   static bool check_alignment(const void *ptr)
   { return (((std::size_t)ptr) % Alignment == 0); }

   static size_type ceil_units(size_type size)
   { return get_rounded_size(size, Alignment)/Alignment; }

   static size_type floor_units(size_type size)
   { return size/Alignment; }

   static size_type multiple_of_units(size_type size)
   { return get_rounded_size(size, Alignment); }

   static multiallocation_chain allocate_many
      (MemoryAlgorithm *memory_algo, size_type elem_bytes, size_type n_elements)
   {
      return this_type::priv_allocate_many(memory_algo, &elem_bytes, n_elements, 0);
   }

   static void deallocate_many(MemoryAlgorithm *memory_algo, multiallocation_chain chain)
   {
      return this_type::priv_deallocate_many(memory_algo, boost::move(chain));
   }

   static bool calculate_lcm_and_needs_backwards_lcmed
      (size_type backwards_multiple, size_type received_size, size_type size_to_achieve,
      size_type &lcm_out, size_type &needs_backwards_lcmed_out)
   {

      size_type max = backwards_multiple;
      size_type min = Alignment;
      size_type needs_backwards;
      size_type needs_backwards_lcmed;
      size_type lcm_val;
      size_type current_forward;

      if(max < min){
         size_type tmp = min;
         min = max;
         max = tmp;
      }

      if((backwards_multiple & (backwards_multiple-1)) == 0){
         if(0 != (size_to_achieve & ((backwards_multiple-1)))){
            return false;
         }

         lcm_val = max;



         current_forward = get_truncated_size_po2(received_size, backwards_multiple);
         needs_backwards = size_to_achieve - current_forward;
         (((needs_backwards % backwards_multiple) == 0) ? static_cast<void> (0) : __assert_fail ("(needs_backwards % backwards_multiple) == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 124, __PRETTY_FUNCTION__));
         needs_backwards_lcmed = get_rounded_size_po2(needs_backwards, lcm_val);
         lcm_out = lcm_val;
         needs_backwards_lcmed_out = needs_backwards_lcmed;
         return true;
      }

      else if((backwards_multiple & (Alignment - 1u)) == 0){
         lcm_val = backwards_multiple;
         current_forward = get_truncated_size(received_size, backwards_multiple);

         needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;
         (((needs_backwards_lcmed & (Alignment - 1u)) == 0) ? static_cast<void> (0) : __assert_fail ("(needs_backwards_lcmed & (Alignment - 1u)) == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 136, __PRETTY_FUNCTION__));
         lcm_out = lcm_val;
         needs_backwards_lcmed_out = needs_backwards_lcmed;
         return true;
      }

      else if((backwards_multiple & ((Alignment/2u) - 1u)) == 0){
         lcm_val = backwards_multiple*2u;
         current_forward = get_truncated_size(received_size, backwards_multiple);
         needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;
         if(0 != (needs_backwards_lcmed & (Alignment-1)))

            needs_backwards_lcmed += backwards_multiple;
         (((needs_backwards_lcmed % lcm_val) == 0) ? static_cast<void> (0) : __assert_fail ("(needs_backwards_lcmed % lcm_val) == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 149, __PRETTY_FUNCTION__));
         lcm_out = lcm_val;
         needs_backwards_lcmed_out = needs_backwards_lcmed;
         return true;
      }

      else if((backwards_multiple & ((Alignment/4u) - 1u)) == 0){
         size_type remainder;
         lcm_val = backwards_multiple*4u;
         current_forward = get_truncated_size(received_size, backwards_multiple);
         needs_backwards_lcmed = needs_backwards = size_to_achieve - current_forward;


         if(0 != (remainder = ((needs_backwards_lcmed & (Alignment-1))>>(Alignment/8u)))){
            if(backwards_multiple & Alignment/2u){
               needs_backwards_lcmed += (remainder)*backwards_multiple;
            }
            else{
               needs_backwards_lcmed += (4-remainder)*backwards_multiple;
            }
         }
         (((needs_backwards_lcmed % lcm_val) == 0) ? static_cast<void> (0) : __assert_fail ("(needs_backwards_lcmed % lcm_val) == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 170, __PRETTY_FUNCTION__));
         lcm_out = lcm_val;
         needs_backwards_lcmed_out = needs_backwards_lcmed;
         return true;
      }
      else{
         lcm_val = lcm(max, min);
      }



      current_forward = get_truncated_size(received_size, backwards_multiple);
      needs_backwards = size_to_achieve - current_forward;
      (((needs_backwards % backwards_multiple) == 0) ? static_cast<void> (0) : __assert_fail ("(needs_backwards % backwards_multiple) == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 183, __PRETTY_FUNCTION__));
      needs_backwards_lcmed = get_rounded_size(needs_backwards, lcm_val);
      lcm_out = lcm_val;
      needs_backwards_lcmed_out = needs_backwards_lcmed;
      return true;
   }

   static multiallocation_chain allocate_many
      ( MemoryAlgorithm *memory_algo
      , const size_type *elem_sizes
      , size_type n_elements
      , size_type sizeof_element)
   {
      return this_type::priv_allocate_many(memory_algo, elem_sizes, n_elements, sizeof_element);
   }

   static void* allocate_aligned
      (MemoryAlgorithm *memory_algo, size_type nbytes, size_type alignment)
   {


      if ((alignment & (alignment - size_type(1u))) != 0){

         (((alignment & (alignment - size_type(1u))) == 0) ? static_cast<void> (0) : __assert_fail ("(alignment & (alignment - size_type(1u))) == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 206, __PRETTY_FUNCTION__));
         return 0;
      }

      size_type real_size;
      if(alignment <= Alignment){
         return memory_algo->priv_allocate
            (boost::interprocess::allocate_new, nbytes, nbytes, real_size).first;
      }

      if(nbytes > UsableByPreviousChunk)
         nbytes -= UsableByPreviousChunk;



      size_type minimum_allocation = max_value
         (nbytes + alignment, size_type(MinBlockUnits*Alignment));
# 232 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp"
      size_type request =
         minimum_allocation + (2*MinBlockUnits*Alignment - AllocatedCtrlBytes

         );


      void *buffer = memory_algo->priv_allocate
         (boost::interprocess::allocate_new, request, request, real_size).first;
      if(!buffer){
         return 0;
      }
      else if ((((std::size_t)(buffer)) % alignment) == 0){


         block_ctrl *first = memory_algo->priv_get_block(buffer);
         size_type old_size = first->m_size;
         const size_type first_min_units =
            max_value(ceil_units(nbytes) + AllocatedCtrlUnits, size_type(MinBlockUnits));

         if(old_size >= (first_min_units + MinBlockUnits)){
            block_ctrl *second = reinterpret_cast<block_ctrl *>
               (reinterpret_cast<char*>(first) + Alignment*first_min_units);
            first->m_size = first_min_units;
            second->m_size = old_size - first->m_size;
            ((second->m_size >= MinBlockUnits) ? static_cast<void> (0) : __assert_fail ("second->m_size >= MinBlockUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 256, __PRETTY_FUNCTION__));
            memory_algo->priv_mark_new_allocated_block(first);

            memory_algo->priv_mark_new_allocated_block(second);
            memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(second));
         }
         return buffer;
      }
# 272 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp"
      char *pos = reinterpret_cast<char*>
         (reinterpret_cast<std::size_t>(static_cast<char*>(buffer) +

            (MinBlockUnits*Alignment - AllocatedCtrlBytes) +

            AllocatedCtrlBytes +

            alignment - 1) & -alignment);


      block_ctrl *first = memory_algo->priv_get_block(buffer);
      block_ctrl *second = memory_algo->priv_get_block(pos);
      ((pos <= (reinterpret_cast<char*>(first) + first->m_size*Alignment)) ? static_cast<void> (0) : __assert_fail ("pos <= (reinterpret_cast<char*>(first) + first->m_size*Alignment)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 284, __PRETTY_FUNCTION__));
      ((first->m_size >= 2*MinBlockUnits) ? static_cast<void> (0) : __assert_fail ("first->m_size >= 2*MinBlockUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 285, __PRETTY_FUNCTION__));
      (((pos + MinBlockUnits*Alignment - AllocatedCtrlBytes + nbytes*Alignment/Alignment) <= (reinterpret_cast<char*>(first) + first->m_size*Alignment)) ? static_cast<void> (0) : __assert_fail ("(pos + MinBlockUnits*Alignment - AllocatedCtrlBytes + nbytes*Alignment/Alignment) <= (reinterpret_cast<char*>(first) + first->m_size*Alignment)",
 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp"
# 286 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 3 4
      ,
 287
# 286 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 3 4
      , __PRETTY_FUNCTION__))
                                                                        ;

      size_type old_size = first->m_size;
      first->m_size = (size_type)(reinterpret_cast<char*>(second) - reinterpret_cast<char*>(first))/Alignment;
      memory_algo->priv_mark_new_allocated_block(first);
# 303 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp"
      const size_type second_min_units = max_value(size_type(MinBlockUnits),
                        ceil_units(nbytes) + AllocatedCtrlUnits );


      if((old_size - first->m_size) >= (second_min_units + MinBlockUnits)){

         block_ctrl *third = new (reinterpret_cast<char*>(second) + Alignment*second_min_units)block_ctrl;
         second->m_size = second_min_units;
         third->m_size = old_size - first->m_size - second->m_size;
         ((third->m_size >= MinBlockUnits) ? static_cast<void> (0) : __assert_fail ("third->m_size >= MinBlockUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 312, __PRETTY_FUNCTION__));
         memory_algo->priv_mark_new_allocated_block(second);
         memory_algo->priv_mark_new_allocated_block(third);
         memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(third));
      }
      else{
         second->m_size = old_size - first->m_size;
         ((second->m_size >= MinBlockUnits) ? static_cast<void> (0) : __assert_fail ("second->m_size >= MinBlockUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 319, __PRETTY_FUNCTION__));
         memory_algo->priv_mark_new_allocated_block(second);
      }

      memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(first));
      return memory_algo->priv_get_user_buffer(second);
   }

   static bool try_shrink
      (MemoryAlgorithm *memory_algo, void *ptr
      ,const size_type max_size, const size_type preferred_size
      ,size_type &received_size)
   {
      (void)memory_algo;

      block_ctrl *block = memory_algo->priv_get_block(ptr);
      size_type old_block_units = (size_type)block->m_size;


      ((memory_algo->priv_is_allocated_block(block)) ? static_cast<void> (0) : __assert_fail ("memory_algo->priv_is_allocated_block(block)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 338, __PRETTY_FUNCTION__));


      assert_alignment(ptr);


      received_size = (old_block_units - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;


      const size_type max_user_units = floor_units(max_size - UsableByPreviousChunk);
      const size_type preferred_user_units = ceil_units(preferred_size - UsableByPreviousChunk);


      if(max_user_units < preferred_user_units)
         return false;


      size_type old_user_units = old_block_units - AllocatedCtrlUnits;

      if(old_user_units < preferred_user_units)
         return false;


      if(old_user_units == preferred_user_units)
         return true;

      size_type shrunk_user_units =
         ((BlockCtrlUnits - AllocatedCtrlUnits) >= preferred_user_units)
         ? (BlockCtrlUnits - AllocatedCtrlUnits)
         : preferred_user_units;


      if(max_user_units < shrunk_user_units)
         return false;


      if((old_user_units - shrunk_user_units) < BlockCtrlUnits ){
         return false;
      }


      received_size = shrunk_user_units*Alignment + UsableByPreviousChunk;
      return true;
   }

   static bool shrink
      (MemoryAlgorithm *memory_algo, void *ptr
      ,const size_type max_size, const size_type preferred_size
      ,size_type &received_size)
   {

      block_ctrl *block = memory_algo->priv_get_block(ptr);
      size_type old_block_units = (size_type)block->m_size;

      if(!try_shrink
         (memory_algo, ptr, max_size, preferred_size, received_size)){
         return false;
      }


      if((old_block_units - AllocatedCtrlUnits) == ceil_units(preferred_size - UsableByPreviousChunk))
         return true;


      block->m_size = (received_size-UsableByPreviousChunk)/Alignment + AllocatedCtrlUnits;
      ((block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 403, __PRETTY_FUNCTION__));


      block_ctrl *new_block = reinterpret_cast<block_ctrl*>
                  (reinterpret_cast<char*>(block) + block->m_size*Alignment);


      new_block->m_size = old_block_units - block->m_size;
      ((new_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("new_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 411, __PRETTY_FUNCTION__));
      memory_algo->priv_mark_new_allocated_block(block);
      memory_algo->priv_mark_new_allocated_block(new_block);
      memory_algo->priv_deallocate(memory_algo->priv_get_user_buffer(new_block));
      return true;
   }

   private:
   static multiallocation_chain priv_allocate_many
      ( MemoryAlgorithm *memory_algo
      , const size_type *elem_sizes
      , size_type n_elements
      , size_type sizeof_element)
   {




      size_type total_request_units = 0;
      size_type elem_units = 0;
      const size_type ptr_size_units = memory_algo->priv_get_total_units(sizeof(void_pointer));
      if(!sizeof_element){
         elem_units = memory_algo->priv_get_total_units(*elem_sizes);
         elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
         total_request_units = n_elements*elem_units;
      }
      else{
         for(size_type i = 0; i < n_elements; ++i){
            elem_units = memory_algo->priv_get_total_units(elem_sizes[i]*sizeof_element);
            elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
            total_request_units += elem_units;
         }
      }

      multiallocation_chain chain;

      size_type low_idx = 0;
      while(low_idx < n_elements){
         size_type total_bytes = total_request_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
         size_type min_allocation = (!sizeof_element)
            ? elem_units
            : memory_algo->priv_get_total_units(elem_sizes[low_idx]*sizeof_element);
         min_allocation = min_allocation*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;

         size_type received_size;
         std::pair<void *, bool> ret = memory_algo->priv_allocate
            (boost::interprocess::allocate_new, min_allocation, total_bytes, received_size, 0);
         if(!ret.first){
            break;
         }

         block_ctrl *block = memory_algo->priv_get_block(ret.first);
         size_type received_units = (size_type)block->m_size;
         char *block_address = reinterpret_cast<char*>(block);

         size_type total_used_units = 0;

         while(total_used_units < received_units){
            if(sizeof_element){
               elem_units = memory_algo->priv_get_total_units(elem_sizes[low_idx]*sizeof_element);
               elem_units = ptr_size_units > elem_units ? ptr_size_units : elem_units;
            }
            if(total_used_units + elem_units > received_units)
               break;
            total_request_units -= elem_units;

            block_ctrl *new_block = reinterpret_cast<block_ctrl *>(block_address);
            assert_alignment(new_block);


            if((low_idx + 1) == n_elements ||
               (total_used_units + elem_units +
               ((!sizeof_element)
                  ? elem_units
              : std::max(memory_algo->priv_get_total_units(elem_sizes[low_idx+1]*sizeof_element), ptr_size_units))
               ) > received_units){

               new_block->m_size = received_units - total_used_units;
               memory_algo->priv_mark_new_allocated_block(new_block);



               if((received_units - total_used_units) >= (elem_units + MemoryAlgorithm::BlockCtrlUnits)){
                  size_type shrunk_received;
                  size_type shrunk_request = elem_units*Alignment - AllocatedCtrlBytes + UsableByPreviousChunk;
                  bool shrink_ok = shrink
                        (memory_algo
                        ,memory_algo->priv_get_user_buffer(new_block)
                        ,shrunk_request
                        ,shrunk_request
                        ,shrunk_received);
                  (void)shrink_ok;

                  ((shrink_ok) ? static_cast<void> (0) : __assert_fail ("shrink_ok", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 504, __PRETTY_FUNCTION__));

                  ((shrunk_request == shrunk_received) ? static_cast<void> (0) : __assert_fail ("shrunk_request == shrunk_received", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 506, __PRETTY_FUNCTION__));
                  ((elem_units == ((shrunk_request-UsableByPreviousChunk)/Alignment + AllocatedCtrlUnits)) ? static_cast<void> (0) : __assert_fail ("elem_units == ((shrunk_request-UsableByPreviousChunk)/Alignment + AllocatedCtrlUnits)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 507, __PRETTY_FUNCTION__));

                  ((new_block->m_size == elem_units) ? static_cast<void> (0) : __assert_fail ("new_block->m_size == elem_units", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 509, __PRETTY_FUNCTION__));

                  received_units = elem_units + total_used_units;
               }
            }
            else{
               new_block->m_size = elem_units;
               memory_algo->priv_mark_new_allocated_block(new_block);
            }

            block_address += new_block->m_size*Alignment;
            total_used_units += (size_type)new_block->m_size;

            (((new_block->m_size*Alignment - AllocatedCtrlUnits) >= sizeof(void_pointer)) ? static_cast<void> (0) : __assert_fail ("(new_block->m_size*Alignment - AllocatedCtrlUnits) >= sizeof(void_pointer)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 522, __PRETTY_FUNCTION__));
            void_pointer p = new(memory_algo->priv_get_user_buffer(new_block))void_pointer(0);
            chain.push_back(p);
            ++low_idx;

         }

         ((total_used_units == received_units) ? static_cast<void> (0) : __assert_fail ("total_used_units == received_units", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp", 529, __PRETTY_FUNCTION__));
      }

      if(low_idx != n_elements){
         priv_deallocate_many(memory_algo, boost::move(chain));
      }
      return boost::move(chain);
   }

   static void priv_deallocate_many(MemoryAlgorithm *memory_algo, multiallocation_chain chain)
   {
      while(!chain.empty()){
         void *addr = to_raw_pointer(chain.front());
         chain.pop_front();
         memory_algo->priv_deallocate(addr);
      }
   }
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 553 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/detail/mem_algo_common.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp"
namespace boost {
namespace interprocess {

template <class T>
struct sizeof_value
{
   static const std::size_t value = sizeof(T);
};

template <>
struct sizeof_value<void>
{
   static const std::size_t value = sizeof(void*);
};

template <>
struct sizeof_value<const void>
{
   static const std::size_t value = sizeof(void*);
};

template <>
struct sizeof_value<volatile void>
{
   static const std::size_t value = sizeof(void*);
};

template <>
struct sizeof_value<const volatile void>
{
   static const std::size_t value = sizeof(void*);
};

namespace ipcdetail {



template<class NodePool>
struct get_or_create_node_pool_func
{



   void operator()()
   {

      mp_node_pool = mp_segment_manager->template find_or_construct
                        <NodePool>(boost::interprocess::unique_instance)(mp_segment_manager);

      if(mp_node_pool != 0)
         mp_node_pool->inc_ref_count();
   }



   get_or_create_node_pool_func(typename NodePool::segment_manager *mngr)
      : mp_segment_manager(mngr){}

   NodePool *mp_node_pool;
   typename NodePool::segment_manager *mp_segment_manager;
};

template<class NodePool>
inline NodePool *get_or_create_node_pool(typename NodePool::segment_manager *mgnr)
{
   ipcdetail::get_or_create_node_pool_func<NodePool> func(mgnr);
   mgnr->atomic_func(func);
   return func.mp_node_pool;
}




template<class NodePool>
struct destroy_if_last_link_func
{


   void operator()()
   {

      if(mp_node_pool->dec_ref_count() != 0) return;


      mp_node_pool->get_segment_manager()->template destroy<NodePool>(boost::interprocess::unique_instance);
   }



   destroy_if_last_link_func(NodePool *pool)
      : mp_node_pool(pool)
   {}

   NodePool *mp_node_pool;
};



template<class NodePool>
inline void destroy_node_pool_if_last_link(NodePool *pool)
{

   typename NodePool::segment_manager *mngr = pool->get_segment_manager();

   destroy_if_last_link_func<NodePool>func(pool);
   mngr->atomic_func(func);
}

template<class NodePool>
class cache_impl
{
   typedef typename NodePool::segment_manager::
      void_pointer void_pointer;
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<NodePool>::type node_pool_ptr;
   typedef typename NodePool::multiallocation_chain multiallocation_chain;
   typedef typename NodePool::segment_manager::size_type size_type;
   node_pool_ptr mp_node_pool;
   multiallocation_chain m_cached_nodes;
   size_type m_max_cached_nodes;

   public:
   typedef typename NodePool::segment_manager segment_manager;

   cache_impl(segment_manager *segment_mngr, size_type max_cached_nodes)
      : mp_node_pool(get_or_create_node_pool<NodePool>(segment_mngr))
      , m_max_cached_nodes(max_cached_nodes)
   {}

   cache_impl(const cache_impl &other)
      : mp_node_pool(other.get_node_pool())
      , m_max_cached_nodes(other.get_max_cached_nodes())
   {
      mp_node_pool->inc_ref_count();
   }

   ~cache_impl()
   {
      this->deallocate_all_cached_nodes();
      ipcdetail::destroy_node_pool_if_last_link(ipcdetail::to_raw_pointer(mp_node_pool));
   }

   NodePool *get_node_pool() const
   { return ipcdetail::to_raw_pointer(mp_node_pool); }

   segment_manager *get_segment_manager() const
   { return mp_node_pool->get_segment_manager(); }

   size_type get_max_cached_nodes() const
   { return m_max_cached_nodes; }

   void *cached_allocation()
   {

      if(m_cached_nodes.empty()){
         m_cached_nodes = mp_node_pool->allocate_nodes(m_max_cached_nodes/2);
      }
      void *ret = ipcdetail::to_raw_pointer(m_cached_nodes.front());
      m_cached_nodes.pop_front();
      return ret;
   }

   multiallocation_chain cached_allocation(size_type n)
   {
      multiallocation_chain chain;
      size_type count = n, allocated(0);
      { try{

         while(!m_cached_nodes.empty() && count--){
            void *ret = ipcdetail::to_raw_pointer(m_cached_nodes.front());
            m_cached_nodes.pop_front();
            chain.push_back(ret);
            ++allocated;
         }

         if(allocated != n){
            multiallocation_chain chain2(mp_node_pool->allocate_nodes(n - allocated));
            chain.splice_after(chain.last(), chain2, chain2.before_begin(), chain2.last(), n - allocated);
         }
         return boost::move(chain);
      }
      catch(...){
         this->cached_deallocation(boost::move(chain));
         throw;
      }
      }
   }

   void cached_deallocation(void *ptr)
   {

      if(m_cached_nodes.size() >= m_max_cached_nodes){




         this->priv_deallocate_n_nodes(m_cached_nodes.size() - m_max_cached_nodes/2);
      }
      m_cached_nodes.push_front(ptr);
   }

   void cached_deallocation(multiallocation_chain chain)
   {
      m_cached_nodes.splice_after(m_cached_nodes.before_begin(), chain);


      if(m_cached_nodes.size() >= m_max_cached_nodes){




         this->priv_deallocate_n_nodes(m_cached_nodes.size() - m_max_cached_nodes/2);
      }
   }



   void set_max_cached_nodes(size_type newmax)
   {
      m_max_cached_nodes = newmax;
      this->priv_deallocate_remaining_nodes();
   }



   void deallocate_all_cached_nodes()
   {
      if(m_cached_nodes.empty()) return;
      mp_node_pool->deallocate_nodes(boost::move(m_cached_nodes));
   }

   private:


   void priv_deallocate_remaining_nodes()
   {
      if(m_cached_nodes.size() > m_max_cached_nodes){
         priv_deallocate_n_nodes(m_cached_nodes.size()-m_max_cached_nodes);
      }
   }


   void priv_deallocate_n_nodes(size_type n)
   {




      size_type count(n);
      typename multiallocation_chain::iterator it(m_cached_nodes.before_begin());
      while(count--){
         ++it;
      }
      multiallocation_chain chain;
      chain.splice_after(chain.before_begin(), m_cached_nodes, m_cached_nodes.before_begin(), it, n);

      mp_node_pool->deallocate_nodes(boost::move(chain));
   }

   public:
   void swap(cache_impl &other)
   {
      ipcdetail::do_swap(mp_node_pool, other.mp_node_pool);
      m_cached_nodes.swap(other.m_cached_nodes);
      ipcdetail::do_swap(m_max_cached_nodes, other.m_max_cached_nodes);
   }
};

template<class Derived, class T, class SegmentManager>
class array_allocation_impl
{
   const Derived *derived() const
   { return static_cast<const Derived*>(this); }
   Derived *derived()
   { return static_cast<Derived*>(this); }

   typedef typename SegmentManager::void_pointer void_pointer;

   public:
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<T>::type pointer;
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<const T>::type const_pointer;
   typedef T value_type;
   typedef typename ipcdetail::add_reference
                     <value_type>::type reference;
   typedef typename ipcdetail::add_reference
                     <const value_type>::type const_reference;
   typedef typename SegmentManager::size_type size_type;
   typedef typename SegmentManager::difference_type difference_type;
   typedef boost::container::container_detail::transform_multiallocation_chain
      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;


   public:



   size_type size(const pointer &p) const
   {
      return (size_type)this->derived()->get_segment_manager()->size(ipcdetail::to_raw_pointer(p))/sizeof(T);
   }

   std::pair<pointer, bool>
      allocation_command(boost::interprocess::allocation_type command,
                         size_type limit_size,
                         size_type preferred_size,
                         size_type &received_size, const pointer &reuse = 0)
   {
      return this->derived()->get_segment_manager()->allocation_command
         (command, limit_size, preferred_size, received_size, ipcdetail::to_raw_pointer(reuse));
   }







   multiallocation_chain allocate_many(size_type elem_size, size_type num_elements)
   {
      return this->derived()->get_segment_manager()->allocate_many(sizeof(T)*elem_size, num_elements);
   }




   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements)
   {
      return this->derived()->get_segment_manager()->allocate_many(elem_sizes, n_elements, sizeof(T));
   }







   void deallocate_many(multiallocation_chain chain)
   { return this->derived()->get_segment_manager()->deallocate_many(boost::move(chain)); }



   size_type max_size() const
   { return this->derived()->get_segment_manager()->get_size()/sizeof(T); }



   pointer address(reference value) const
   { return pointer(boost::addressof(value)); }



   const_pointer address(const_reference value) const
   { return const_pointer(boost::addressof(value)); }




   template<class P>
   void construct(const pointer &ptr, const P & p)
   { ::new((void*)ipcdetail::to_raw_pointer(ptr)) value_type(::boost::forward<P>(p)); }



   void destroy(const pointer &ptr)
   { ((ptr != 0) ? static_cast<void> (0) : __assert_fail ("ptr != 0", "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp", 405, __PRETTY_FUNCTION__)); (*ptr).~value_type(); }
};


template<class Derived, unsigned int Version, class T, class SegmentManager>
class node_pool_allocation_impl
   : public array_allocation_impl
      < Derived
      , T
      , SegmentManager>
{
   const Derived *derived() const
   { return static_cast<const Derived*>(this); }
   Derived *derived()
   { return static_cast<Derived*>(this); }

   typedef typename SegmentManager::void_pointer void_pointer;
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<const void>::type cvoid_pointer;

   public:
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<T>::type pointer;
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<const T>::type const_pointer;
   typedef T value_type;
   typedef typename ipcdetail::add_reference
                     <value_type>::type reference;
   typedef typename ipcdetail::add_reference
                     <const value_type>::type const_reference;
   typedef typename SegmentManager::size_type size_type;
   typedef typename SegmentManager::difference_type difference_type;
   typedef boost::container::container_detail::transform_multiallocation_chain
      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;


   template <int Dummy>
   struct node_pool
   {
      typedef typename Derived::template node_pool<0>::type type;
      static type *get(void *p)
      { return static_cast<type*>(p); }
   };

   public:


   pointer allocate(size_type count, cvoid_pointer hint = 0)
   {
      (void)hint;
      typedef typename node_pool<0>::type node_pool_t;
      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
      if(count > this->max_size())
         throw bad_alloc();
      else if(Version == 1 && count == 1)
         return pointer(static_cast<value_type*>
         (pool->allocate_node()));
      else
         return pointer(static_cast<value_type*>
            (pool->get_segment_manager()->allocate(sizeof(T)*count)));
   }


   void deallocate(const pointer &ptr, size_type count)
   {
      (void)count;
      typedef typename node_pool<0>::type node_pool_t;
      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
      if(Version == 1 && count == 1)
         pool->deallocate_node(ipcdetail::to_raw_pointer(ptr));
      else
         pool->get_segment_manager()->deallocate((void*)ipcdetail::to_raw_pointer(ptr));
   }




   pointer allocate_one()
   {
      typedef typename node_pool<0>::type node_pool_t;
      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
      return pointer(static_cast<value_type*>(pool->allocate_node()));
   }







   multiallocation_chain allocate_individual(size_type num_elements)
   {
      typedef typename node_pool<0>::type node_pool_t;
      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
      return multiallocation_chain(pool->allocate_nodes(num_elements));
   }




   void deallocate_one(const pointer &p)
   {
      typedef typename node_pool<0>::type node_pool_t;
      node_pool_t *pool = node_pool<0>::get(this->derived()->get_node_pool());
      pool->deallocate_node(ipcdetail::to_raw_pointer(p));
   }







   void deallocate_individual(multiallocation_chain chain)
   {
      node_pool<0>::get(this->derived()->get_node_pool())->deallocate_nodes
         (chain.extract_multiallocation_chain());
   }


   void deallocate_free_blocks()
   { node_pool<0>::get(this->derived()->get_node_pool())->deallocate_free_blocks(); }



   void deallocate_free_chunks()
   { node_pool<0>::get(this->derived()->get_node_pool())->deallocate_free_blocks(); }
};

template<class T, class NodePool, unsigned int Version>
class cached_allocator_impl
   : public array_allocation_impl
         <cached_allocator_impl<T, NodePool, Version>, T, typename NodePool::segment_manager>
{
   cached_allocator_impl & operator=(const cached_allocator_impl& other);
   typedef array_allocation_impl
         < cached_allocator_impl
            <T, NodePool, Version>
         , T
         , typename NodePool::segment_manager> base_t;

   public:
   typedef NodePool node_pool_t;
   typedef typename NodePool::segment_manager segment_manager;
   typedef typename segment_manager::void_pointer void_pointer;
   typedef typename boost::intrusive::
      pointer_traits<void_pointer>::template
         rebind_pointer<const void>::type cvoid_pointer;
   typedef typename base_t::pointer pointer;
   typedef typename base_t::size_type size_type;
   typedef typename base_t::multiallocation_chain multiallocation_chain;
   typedef typename base_t::value_type value_type;

   public:
   static const std::size_t DEFAULT_MAX_CACHED_NODES = 64;

   cached_allocator_impl(segment_manager *segment_mngr, size_type max_cached_nodes)
      : m_cache(segment_mngr, max_cached_nodes)
   {}

   cached_allocator_impl(const cached_allocator_impl &other)
      : m_cache(other.m_cache)
   {}




   template<class T2, class NodePool2>
   cached_allocator_impl
      (const cached_allocator_impl
         <T2, NodePool2, Version> &other)
      : m_cache(other.get_segment_manager(), other.get_max_cached_nodes())
   {}



   node_pool_t* get_node_pool() const
   { return m_cache.get_node_pool(); }



   segment_manager* get_segment_manager()const
   { return m_cache.get_segment_manager(); }



   void set_max_cached_nodes(size_type newmax)
   { m_cache.set_max_cached_nodes(newmax); }



   size_type get_max_cached_nodes() const
   { return m_cache.get_max_cached_nodes(); }



   pointer allocate(size_type count, cvoid_pointer hint = 0)
   {
      (void)hint;
      void * ret;
      if(count > this->max_size())
         throw bad_alloc();
      else if(Version == 1 && count == 1){
         ret = m_cache.cached_allocation();
      }
      else{
         ret = this->get_segment_manager()->allocate(sizeof(T)*count);
      }
      return pointer(static_cast<T*>(ret));
   }


   void deallocate(const pointer &ptr, size_type count)
   {
      (void)count;
      if(Version == 1 && count == 1){
         m_cache.cached_deallocation(ipcdetail::to_raw_pointer(ptr));
      }
      else{
         this->get_segment_manager()->deallocate((void*)ipcdetail::to_raw_pointer(ptr));
      }
   }




   pointer allocate_one()
   { return pointer(static_cast<value_type*>(this->m_cache.cached_allocation())); }







   multiallocation_chain allocate_individual(size_type num_elements)
   { return multiallocation_chain(this->m_cache.cached_allocation(num_elements)); }




   void deallocate_one(const pointer &p)
   { this->m_cache.cached_deallocation(ipcdetail::to_raw_pointer(p)); }







   void deallocate_individual(multiallocation_chain chain)
   {
      typename node_pool_t::multiallocation_chain mem
         (chain.extract_multiallocation_chain());
      m_cache.cached_deallocation(boost::move(mem));
   }


   void deallocate_free_blocks()
   { m_cache.get_node_pool()->deallocate_free_blocks(); }



   friend void swap(cached_allocator_impl &alloc1, cached_allocator_impl &alloc2)
   { alloc1.m_cache.swap(alloc2.m_cache); }

   void deallocate_cache()
   { m_cache.deallocate_all_cached_nodes(); }


   void deallocate_free_chunks()
   { m_cache.get_node_pool()->deallocate_free_blocks(); }


   private:
   cache_impl<node_pool_t> m_cache;
};



template<class T, class N, unsigned int V> inline
bool operator==(const cached_allocator_impl<T, N, V> &alloc1,
                const cached_allocator_impl<T, N, V> &alloc2)
   { return alloc1.get_node_pool() == alloc2.get_node_pool(); }



template<class T, class N, unsigned int V> inline
bool operator!=(const cached_allocator_impl<T, N, V> &alloc1,
                const cached_allocator_impl<T, N, V> &alloc2)
   { return alloc1.get_node_pool() != alloc2.get_node_pool(); }






template<class private_node_allocator_t>
class shared_pool_impl
   : public private_node_allocator_t
{
 public:

   typedef typename private_node_allocator_t::
      segment_manager segment_manager;
   typedef typename private_node_allocator_t::
      multiallocation_chain multiallocation_chain;
   typedef typename private_node_allocator_t::
     size_type size_type;

 private:
   typedef typename segment_manager::mutex_family::mutex_type mutex_type;

 public:

   shared_pool_impl(segment_manager *segment_mngr)
      : private_node_allocator_t(segment_mngr)
   {}


   ~shared_pool_impl()
   {}


   void *allocate_node()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      return private_node_allocator_t::allocate_node();
   }


   void deallocate_node(void *ptr)
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::deallocate_node(ptr);
   }
# 761 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp"
   multiallocation_chain allocate_nodes(const size_type n)
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      return private_node_allocator_t::allocate_nodes(n);
   }


   void deallocate_nodes(multiallocation_chain &nodes, size_type num)
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::deallocate_nodes(nodes, num);
   }


   void deallocate_nodes(multiallocation_chain chain)
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::deallocate_nodes(boost::move(chain));
   }


   void deallocate_free_blocks()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::deallocate_free_blocks();
   }




   void purge_blocks()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::purge_blocks();
   }


   size_type inc_ref_count()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      return ++m_header.m_usecount;
   }


   size_type dec_ref_count()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      ((m_header.m_usecount > 0) ? static_cast<void> (0) : __assert_fail ("m_header.m_usecount > 0", "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp", 822, __PRETTY_FUNCTION__));
      return --m_header.m_usecount;
   }


   void deallocate_free_chunks()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::deallocate_free_blocks();
   }


   void purge_chunks()
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      private_node_allocator_t::purge_blocks();
   }

   private:


   struct header_t : mutex_type
   {
      size_type m_usecount;

      header_t()
      : m_usecount(0) {}
   } m_header;
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 861 "/opt/sevenflow/boost/include/boost/interprocess/allocators/detail/allocator_common.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 31 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2






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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 38 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2






namespace boost {
namespace interprocess {






template<class T, class SegmentManager>
class allocator
{
   public:

   typedef SegmentManager segment_manager;
   typedef typename SegmentManager::void_pointer void_pointer;


   private:


   typedef allocator<T, SegmentManager> self_t;


   typedef typename segment_manager::void_pointer aux_pointer_t;


   typedef typename boost::intrusive::
      pointer_traits<aux_pointer_t>::template
         rebind_pointer<const void>::type cvoid_ptr;


   typedef typename boost::intrusive::
      pointer_traits<cvoid_ptr>::template
         rebind_pointer<segment_manager>::type alloc_ptr_t;


   template<class T2, class SegmentManager2>
   allocator& operator=(const allocator<T2, SegmentManager2>&);


   allocator& operator=(const allocator&);


   alloc_ptr_t mp_mngr;


   public:
   typedef T value_type;
   typedef typename boost::intrusive::
      pointer_traits<cvoid_ptr>::template
         rebind_pointer<T>::type pointer;
   typedef typename boost::intrusive::
      pointer_traits<pointer>::template
         rebind_pointer<const T>::type const_pointer;
   typedef typename ipcdetail::add_reference
                     <value_type>::type reference;
   typedef typename ipcdetail::add_reference
                     <const value_type>::type const_reference;
   typedef typename segment_manager::size_type size_type;
   typedef typename segment_manager::difference_type difference_type;

   typedef boost::interprocess::version_type<allocator, 2> version;




   typedef boost::container::container_detail::transform_multiallocation_chain
      <typename SegmentManager::multiallocation_chain, T>multiallocation_chain;




   template<class T2>
   struct rebind
   {
      typedef allocator<T2, SegmentManager> other;
   };



   segment_manager* get_segment_manager()const
   { return ipcdetail::to_raw_pointer(mp_mngr); }



   allocator(segment_manager *segment_mngr)
      : mp_mngr(segment_mngr) { }



   allocator(const allocator &other)
      : mp_mngr(other.get_segment_manager()){ }



   template<class T2>
   allocator(const allocator<T2, SegmentManager> &other)
      : mp_mngr(other.get_segment_manager()){}



   pointer allocate(size_type count, cvoid_ptr hint = 0)
   {
      (void)hint;
      if(count > this->max_size())
         throw bad_alloc();
      return pointer(static_cast<value_type*>(mp_mngr->allocate(count*sizeof(T))));
   }



   void deallocate(const pointer &ptr, size_type)
   { mp_mngr->deallocate((void*)ipcdetail::to_raw_pointer(ptr)); }



   size_type max_size() const
   { return mp_mngr->get_size()/sizeof(T); }



   friend void swap(self_t &alloc1, self_t &alloc2)
   { ipcdetail::do_swap(alloc1.mp_mngr, alloc2.mp_mngr); }




   size_type size(const pointer &p) const
   {
      return (size_type)mp_mngr->size(ipcdetail::to_raw_pointer(p))/sizeof(T);
   }

   std::pair<pointer, bool>
      allocation_command(boost::interprocess::allocation_type command,
                         size_type limit_size,
                         size_type preferred_size,
                         size_type &received_size, const pointer &reuse = 0)
   {
      return mp_mngr->allocation_command
         (command, limit_size, preferred_size, received_size, ipcdetail::to_raw_pointer(reuse));
   }







   multiallocation_chain allocate_many
      (size_type elem_size, size_type num_elements)
   {
      return multiallocation_chain(mp_mngr->allocate_many(sizeof(T)*elem_size, num_elements));
   }




   multiallocation_chain allocate_many
      (const size_type *elem_sizes, size_type n_elements)
   {
      multiallocation_chain(mp_mngr->allocate_many(elem_sizes, n_elements, sizeof(T)));
   }







   void deallocate_many(multiallocation_chain chain)
   {
      return mp_mngr->deallocate_many(chain.extract_multiallocation_chain());
   }




   pointer allocate_one()
   { return this->allocate(1); }







   multiallocation_chain allocate_individual
      (size_type num_elements)
   { return this->allocate_many(1, num_elements); }




   void deallocate_one(const pointer &p)
   { return this->deallocate(p, 1); }







   void deallocate_individual(multiallocation_chain chain)
   { return this->deallocate_many(boost::move(chain)); }



   pointer address(reference value) const
   { return pointer(boost::addressof(value)); }



   const_pointer address(const_reference value) const
   { return const_pointer(boost::addressof(value)); }




   template<class P>
   void construct(const pointer &ptr, const P & p)
   { ::new((void*)ipcdetail::to_raw_pointer(ptr)) value_type(::boost::forward<P>(p)); }



   void destroy(const pointer &ptr)
   { ((ptr != 0) ? static_cast<void> (0) : __assert_fail ("ptr != 0", "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp", 269, __PRETTY_FUNCTION__)); (*ptr).~value_type(); }

};



template<class T, class SegmentManager> inline
bool operator==(const allocator<T , SegmentManager> &alloc1,
                const allocator<T, SegmentManager> &alloc2)
   { return alloc1.get_segment_manager() == alloc2.get_segment_manager(); }



template<class T, class SegmentManager> inline
bool operator!=(const allocator<T, SegmentManager> &alloc1,
                const allocator<T, SegmentManager> &alloc2)
   { return alloc1.get_segment_manager() != alloc2.get_segment_manager(); }

}



template<class T>
struct has_trivial_destructor;

template<class T, class SegmentManager>
struct has_trivial_destructor
   <boost::interprocess::allocator <T, SegmentManager> >
{
   static const bool value = true;
};


}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 305 "/opt/sevenflow/boost/include/boost/interprocess/allocators/allocator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/smart_ptr/deleter.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/interprocess/smart_ptr/deleter.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/smart_ptr/deleter.hpp" 2







namespace boost {
namespace interprocess {





template<class T, class SegmentManager>
class deleter
{
   public:
   typedef typename boost::intrusive::
      pointer_traits<typename SegmentManager::void_pointer>::template
         rebind_pointer<T>::type pointer;

   private:
   typedef typename boost::intrusive::
      pointer_traits<pointer>::template
         rebind_pointer<SegmentManager>::type segment_manager_pointer;

   segment_manager_pointer mp_mngr;

   public:
   deleter(segment_manager_pointer pmngr)
      : mp_mngr(pmngr)
   {}

   void operator()(const pointer &p)
   { mp_mngr->destroy_ptr(ipcdetail::to_raw_pointer(p)); }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 63 "/opt/sevenflow/boost/include/boost/interprocess/smart_ptr/deleter.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 38 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2
# 51 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
namespace boost{
namespace interprocess{
# 63 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
template<class MemoryAlgorithm>
class segment_manager_base
   : private MemoryAlgorithm
{
   public:
   typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_type;
   typedef typename MemoryAlgorithm::void_pointer void_pointer;
   typedef typename MemoryAlgorithm::mutex_family mutex_family;
   typedef MemoryAlgorithm memory_algorithm;




   typedef typename MemoryAlgorithm::multiallocation_chain multiallocation_chain;
   typedef typename MemoryAlgorithm::difference_type difference_type;
   typedef typename MemoryAlgorithm::size_type size_type;





   static const size_type PayloadPerAllocation = MemoryAlgorithm::PayloadPerAllocation;
# 97 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
   segment_manager_base(size_type size, size_type reserved_bytes)
      : MemoryAlgorithm(size, reserved_bytes)
   {
      (((sizeof(segment_manager_base<MemoryAlgorithm>) == sizeof(MemoryAlgorithm))) ? static_cast<void> (0) : __assert_fail ("(sizeof(segment_manager_base<MemoryAlgorithm>) == sizeof(MemoryAlgorithm))", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 100, __PRETTY_FUNCTION__));
   }



   size_type get_size() const
   { return MemoryAlgorithm::get_size(); }



   size_type get_free_memory() const
   { return MemoryAlgorithm::get_free_memory(); }



   static size_type get_min_size (size_type size)
   { return MemoryAlgorithm::get_min_size(size); }



   void * allocate (size_type nbytes, std::nothrow_t)
   { return MemoryAlgorithm::allocate(nbytes); }






   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
   {
      multiallocation_chain mem(MemoryAlgorithm::allocate_many(elem_bytes, num_elements));
      if(mem.empty()) throw bad_alloc();
      return boost::move(mem);
   }



   multiallocation_chain allocate_many
      (const size_type *element_lenghts, size_type n_elements, size_type sizeof_element = 1)
   {
      multiallocation_chain mem(MemoryAlgorithm::allocate_many(element_lenghts, n_elements, sizeof_element));
      if(mem.empty()) throw bad_alloc();
      return boost::move(mem);
   }



   multiallocation_chain allocate_many
      (size_type elem_bytes, size_type num_elements, std::nothrow_t)
   { return MemoryAlgorithm::allocate_many(elem_bytes, num_elements); }




   multiallocation_chain allocate_many
      (const size_type *elem_sizes, size_type n_elements, size_type sizeof_element, std::nothrow_t)
   { return MemoryAlgorithm::allocate_many(elem_sizes, n_elements, sizeof_element); }



   void deallocate_many(multiallocation_chain chain)
   { MemoryAlgorithm::deallocate_many(boost::move(chain)); }





   void * allocate(size_type nbytes)
   {
      void * ret = MemoryAlgorithm::allocate(nbytes);
      if(!ret)
         throw bad_alloc();
      return ret;
   }



   void * allocate_aligned (size_type nbytes, size_type alignment, std::nothrow_t)
   { return MemoryAlgorithm::allocate_aligned(nbytes, alignment); }



   void * allocate_aligned(size_type nbytes, size_type alignment)
   {
      void * ret = MemoryAlgorithm::allocate_aligned(nbytes, alignment);
      if(!ret)
         throw bad_alloc();
      return ret;
   }

   template<class T>
   std::pair<T *, bool>
      allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
                           size_type preferred_size,size_type &received_size,
                           T *reuse_ptr = 0)
   {
      std::pair<T *, bool> ret = MemoryAlgorithm::allocation_command
         ( command | boost::interprocess::nothrow_allocation, limit_size, preferred_size, received_size
         , reuse_ptr);
      if(!(command & boost::interprocess::nothrow_allocation) && !ret.first)
         throw bad_alloc();
      return ret;
   }

   std::pair<void *, bool>
      raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_objects,
                           size_type preferred_objects,size_type &received_objects,
                           void *reuse_ptr = 0, size_type sizeof_object = 1)
   {
      std::pair<void *, bool> ret = MemoryAlgorithm::raw_allocation_command
         ( command | boost::interprocess::nothrow_allocation, limit_objects, preferred_objects, received_objects
         , reuse_ptr, sizeof_object);
      if(!(command & boost::interprocess::nothrow_allocation) && !ret.first)
         throw bad_alloc();
      return ret;
   }



   void deallocate (void *addr)
   { MemoryAlgorithm::deallocate(addr); }



   void grow(size_type extra_size)
   { MemoryAlgorithm::grow(extra_size); }



   void shrink_to_fit()
   { MemoryAlgorithm::shrink_to_fit(); }



   bool all_memory_deallocated()
   { return MemoryAlgorithm::all_memory_deallocated(); }



   bool check_sanity()
   { return MemoryAlgorithm::check_sanity(); }



   void zero_free_memory()
   { MemoryAlgorithm::zero_free_memory(); }


   size_type size(const void *ptr) const
   { return MemoryAlgorithm::size(ptr); }


   protected:
   void * prot_anonymous_construct
      (size_type num, bool dothrow, ipcdetail::in_place_interface &table)
   {
      typedef ipcdetail::block_header<size_type> block_header_t;
      block_header_t block_info ( size_type(table.size*num)
                                 , size_type(table.alignment)
                                 , anonymous_type
                                 , 1
                                 , 0);


      void *ptr_struct = this->allocate(block_info.total_size(), std::nothrow_t());


      if(!ptr_struct){
         if(dothrow){
            throw bad_alloc();
         }
         else{
            return 0;
         }
      }


      ipcdetail::mem_algo_deallocator<MemoryAlgorithm> mem(ptr_struct, *this);


      block_header_t * hdr = new(ptr_struct) block_header_t(block_info);
      void *ptr = 0;
      ptr = hdr->value();


      ipcdetail::array_construct(ptr, num, table);


      mem.release();
      return ptr;
   }


   void prot_anonymous_destroy(const void *object, ipcdetail::in_place_interface &table)
   {


      typedef ipcdetail::block_header<size_type> block_header_t;
      block_header_t *ctrl_data = block_header_t::block_header_from_value(object, table.size, table.alignment);





      if(ctrl_data->alloc_type() != anonymous_type){

         ((0) ? static_cast<void> (0) : __assert_fail ("0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 306, __PRETTY_FUNCTION__));
      }



      std::size_t destroyed = 0;
     table.destroy_n(const_cast<void*>(object), ctrl_data->m_value_bytes/table.size, destroyed);
      this->deallocate(ctrl_data);
   }

};
# 334 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
template<class CharType
        ,class MemoryAlgorithm
        ,template<class IndexConfig> class IndexType>
class segment_manager
   : public segment_manager_base<MemoryAlgorithm>
{


   segment_manager();
   segment_manager(const segment_manager &);
   segment_manager &operator=(const segment_manager &);
   typedef segment_manager_base<MemoryAlgorithm> Base;


   public:
   typedef MemoryAlgorithm memory_algorithm;
   typedef typename Base::void_pointer void_pointer;
   typedef typename Base::size_type size_type;
   typedef typename Base::difference_type difference_type;
   typedef CharType char_type;

   typedef segment_manager_base<MemoryAlgorithm> segment_manager_base_type;

   static const size_type PayloadPerAllocation = Base::PayloadPerAllocation;


   private:
   typedef ipcdetail::block_header<size_type> block_header_t;
   typedef ipcdetail::index_config<CharType, MemoryAlgorithm> index_config_named;
   typedef ipcdetail::index_config<char, MemoryAlgorithm> index_config_unique;
   typedef IndexType<index_config_named> index_type;
   typedef ipcdetail::bool_<is_intrusive_index<index_type>::value > is_intrusive_t;
   typedef ipcdetail::bool_<is_node_index<index_type>::value> is_node_index_t;

   public:
   typedef IndexType<index_config_named> named_index_t;
   typedef IndexType<index_config_unique> unique_index_t;
   typedef ipcdetail::char_ptr_holder<CharType> char_ptr_holder_t;
   typedef ipcdetail::segment_manager_iterator_transform
      <typename named_index_t::const_iterator
      ,is_intrusive_index<index_type>::value> named_transform;

   typedef ipcdetail::segment_manager_iterator_transform
      <typename unique_index_t::const_iterator
      ,is_intrusive_index<index_type>::value> unique_transform;


   typedef typename Base::mutex_family mutex_family;

   typedef transform_iterator
      <typename named_index_t::const_iterator, named_transform> const_named_iterator;
   typedef transform_iterator
      <typename unique_index_t::const_iterator, unique_transform> const_unique_iterator;




   template<class T>
   struct construct_proxy
   {
      typedef ipcdetail::named_proxy<segment_manager, T, false> type;
   };


   template<class T>
   struct construct_iter_proxy
   {
      typedef ipcdetail::named_proxy<segment_manager, T, true> type;
   };







   segment_manager(size_type size)
      : Base(size, priv_get_reserved_bytes())
      , m_header(static_cast<Base*>(get_this_pointer()))
   {
      (void) anonymous_instance; (void) unique_instance;
      ((static_cast<const void*>(this) == static_cast<const void*>(static_cast<Base*>(this))) ? static_cast<void> (0) : __assert_fail ("static_cast<const void*>(this) == static_cast<const void*>(static_cast<Base*>(this))", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 415, __PRETTY_FUNCTION__));
   }




   template <class T>
   std::pair<T*, size_type> find (const CharType* name)
   { return this->priv_find_impl<T>(name, true); }




   template <class T>
   std::pair<T*, size_type> find (const ipcdetail::unique_instance_t* name)
   { return this->priv_find_impl<T>(name, true); }




   template <class T>
   std::pair<T*, size_type> find_no_lock (const CharType* name)
   { return this->priv_find_impl<T>(name, false); }




   template <class T>
   std::pair<T*, size_type> find_no_lock (const ipcdetail::unique_instance_t* name)
   { return this->priv_find_impl<T>(name, false); }



   template <class T>
   typename construct_proxy<T>::type
      construct(char_ptr_holder_t name)
   { return typename construct_proxy<T>::type (this, name, false, true); }



   template <class T>
   typename construct_proxy<T>::type find_or_construct(char_ptr_holder_t name)
   { return typename construct_proxy<T>::type (this, name, true, true); }



   template <class T>
   typename construct_proxy<T>::type
      construct(char_ptr_holder_t name, std::nothrow_t)
   { return typename construct_proxy<T>::type (this, name, false, false); }



   template <class T>
   typename construct_proxy<T>::type
      find_or_construct(char_ptr_holder_t name, std::nothrow_t)
   { return typename construct_proxy<T>::type (this, name, true, false); }


   template <class T>
   typename construct_iter_proxy<T>::type
      construct_it(char_ptr_holder_t name)
   { return typename construct_iter_proxy<T>::type (this, name, false, true); }



   template <class T>
   typename construct_iter_proxy<T>::type
      find_or_construct_it(char_ptr_holder_t name)
   { return typename construct_iter_proxy<T>::type (this, name, true, true); }



   template <class T>
   typename construct_iter_proxy<T>::type
      construct_it(char_ptr_holder_t name, std::nothrow_t)
   { return typename construct_iter_proxy<T>::type (this, name, false, false); }



   template <class T>
   typename construct_iter_proxy<T>::type
      find_or_construct_it(char_ptr_holder_t name, std::nothrow_t)
   { return typename construct_iter_proxy<T>::type (this, name, true, false); }




   template <class Func>
   void atomic_func(Func &f)
   { scoped_lock<rmutex> guard(m_header); f(); }






   template <class Func>
   bool try_atomic_func(Func &f)
   {
      scoped_lock<rmutex> guard(m_header, try_to_lock);
      if(guard){
         f();
         return true;
      }
      else{
         return false;
      }
   }



   template <class T>
   bool destroy(const ipcdetail::unique_instance_t *)
   {
      ipcdetail::placement_destroy<T> dtor;
      return this->priv_generic_named_destroy<char>
         (typeid(T).name(), m_header.m_unique_index, dtor, is_intrusive_t());
   }



   template <class T>
   bool destroy(const CharType *name)
   {
      ipcdetail::placement_destroy<T> dtor;
      return this->priv_generic_named_destroy<CharType>
               (name, m_header.m_named_index, dtor, is_intrusive_t());
   }



   template <class T>
   void destroy_ptr(const T *p)
   {

      typedef typename ipcdetail::char_if_void<T>::type data_t;
      ipcdetail::placement_destroy<data_t> dtor;
      priv_destroy_ptr(p, dtor);
   }



   template<class T>
   static const CharType *get_instance_name(const T *ptr)
   { return priv_get_instance_name(block_header_t::block_header_from_value(ptr)); }



   template<class T>
   static size_type get_instance_length(const T *ptr)
   { return priv_get_instance_length(block_header_t::block_header_from_value(ptr), sizeof(T)); }



   template<class T>
   static instance_type get_instance_type(const T *ptr)
   { return priv_get_instance_type(block_header_t::block_header_from_value(ptr)); }




   void reserve_named_objects(size_type num)
   {

      scoped_lock<rmutex> guard(m_header);

      m_header.m_named_index.reserve(num);
   }




   void reserve_unique_objects(size_type num)
   {

      scoped_lock<rmutex> guard(m_header);

      m_header.m_unique_index.reserve(num);
   }



   void shrink_to_fit_indexes()
   {

      scoped_lock<rmutex> guard(m_header);

      m_header.m_named_index.shrink_to_fit();
      m_header.m_unique_index.shrink_to_fit();
   }



   size_type get_num_named_objects()
   {

      scoped_lock<rmutex> guard(m_header);

      return m_header.m_named_index.size();
   }



   size_type get_num_unique_objects()
   {

      scoped_lock<rmutex> guard(m_header);

      return m_header.m_unique_index.size();
   }



   static size_type get_min_size()
   { return Base::get_min_size(priv_get_reserved_bytes()); }



   const_named_iterator named_begin() const
   {
      return make_transform_iterator
         (m_header.m_named_index.begin(), named_transform());
   }



   const_named_iterator named_end() const
   {
      return make_transform_iterator
         (m_header.m_named_index.end(), named_transform());
   }



   const_unique_iterator unique_begin() const
   {
      return make_transform_iterator
         (m_header.m_unique_index.begin(), unique_transform());
   }



   const_unique_iterator unique_end() const
   {
      return make_transform_iterator
         (m_header.m_unique_index.end(), unique_transform());
   }



   template<class T>
   struct allocator
   {
      typedef boost::interprocess::allocator<T, segment_manager> type;
   };



   template<class T>
   typename allocator<T>::type
      get_allocator()
   { return typename allocator<T>::type(this); }



   template<class T>
   struct deleter
   {
      typedef boost::interprocess::deleter<T, segment_manager> type;
   };



   template<class T>
   typename deleter<T>::type
      get_deleter()
   { return typename deleter<T>::type(this); }






   template<class T>
   T *generic_construct(const CharType *name,
                        size_type num,
                         bool try2find,
                         bool dothrow,
                         ipcdetail::in_place_interface &table)
   {
      return static_cast<T*>
         (priv_generic_construct(name, num, try2find, dothrow, table));
   }

   private:



   template <class T>
   std::pair<T*, size_type> priv_find_impl (const CharType* name, bool lock)
   {

      ((name != 0) ? static_cast<void> (0) : __assert_fail ("name != 0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 718, __PRETTY_FUNCTION__));
      ipcdetail::placement_destroy<T> table;
      size_type size;
      void *ret;

      if(name == reinterpret_cast<const CharType*>(-1)){
         ret = priv_generic_find<char> (typeid(T).name(), m_header.m_unique_index, table, size, is_intrusive_t(), lock);
      }
      else{
         ret = priv_generic_find<CharType> (name, m_header.m_named_index, table, size, is_intrusive_t(), lock);
      }
      return std::pair<T*, size_type>(static_cast<T*>(ret), size);
   }




   template <class T>
   std::pair<T*, size_type> priv_find__impl (const ipcdetail::unique_instance_t* name, bool lock)
   {
      ipcdetail::placement_destroy<T> table;
      size_type size;
      void *ret = priv_generic_find<char>(name, m_header.m_unique_index, table, size, is_intrusive_t(), lock);
      return std::pair<T*, size_type>(static_cast<T*>(ret), size);
   }

   void *priv_generic_construct(const CharType *name,
                   size_type num,
                         bool try2find,
                         bool dothrow,
                         ipcdetail::in_place_interface &table)
   {
      void *ret;

     if(num > ((std::size_t)-1)/table.size){
         if(dothrow)
            throw bad_alloc();
         else
            return 0;
      }
      if(name == 0){
         ret = this->prot_anonymous_construct(num, dothrow, table);
      }
      else if(name == reinterpret_cast<const CharType*>(-1)){
         ret = this->priv_generic_named_construct<char>
            (unique_type, table.type_name, num, try2find, dothrow, table, m_header.m_unique_index, is_intrusive_t());
      }
      else{
         ret = this->priv_generic_named_construct<CharType>
            (named_type, name, num, try2find, dothrow, table, m_header.m_named_index, is_intrusive_t());
      }
      return ret;
   }

   void priv_destroy_ptr(const void *ptr, ipcdetail::in_place_interface &dtor)
   {
      block_header_t *ctrl_data = block_header_t::block_header_from_value(ptr, dtor.size, dtor.alignment);
      switch(ctrl_data->alloc_type()){
         case anonymous_type:
            this->prot_anonymous_destroy(ptr, dtor);
         break;

         case named_type:
            this->priv_generic_named_destroy<CharType>
               (ctrl_data, m_header.m_named_index, dtor, is_node_index_t());
         break;

         case unique_type:
            this->priv_generic_named_destroy<char>
               (ctrl_data, m_header.m_unique_index, dtor, is_node_index_t());
         break;

         default:

            ((0) ? static_cast<void> (0) : __assert_fail ("0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 792, __PRETTY_FUNCTION__));
         break;
      }
   }



   static const CharType *priv_get_instance_name(block_header_t *ctrl_data)
   {
      boost::interprocess::allocation_type type = ctrl_data->alloc_type();
      if(type != named_type){
         (((type == anonymous_type && ctrl_data->m_num_char == 0) || (type == unique_type && ctrl_data->m_num_char != 0)) ? static_cast<void> (0) : __assert_fail ("(type == anonymous_type && ctrl_data->m_num_char == 0) || (type == unique_type && ctrl_data->m_num_char != 0)",
 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
# 803 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 3 4
         ,
 804
# 803 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 3 4
         , __PRETTY_FUNCTION__))
                                                                        ;
         return 0;
      }
      CharType *name = static_cast<CharType*>(ctrl_data->template name<CharType>());


      ((ctrl_data->sizeof_char() == sizeof(CharType)) ? static_cast<void> (0) : __assert_fail ("ctrl_data->sizeof_char() == sizeof(CharType)", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 810, __PRETTY_FUNCTION__));
      ((ctrl_data->m_num_char == std::char_traits<CharType>::length(name)) ? static_cast<void> (0) : __assert_fail ("ctrl_data->m_num_char == std::char_traits<CharType>::length(name)", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 811, __PRETTY_FUNCTION__));
      return name;
   }

   static size_type priv_get_instance_length(block_header_t *ctrl_data, size_type sizeofvalue)
   {

      (((ctrl_data->value_bytes() %sizeofvalue) == 0) ? static_cast<void> (0) : __assert_fail ("(ctrl_data->value_bytes() %sizeofvalue) == 0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 818, __PRETTY_FUNCTION__));
      return ctrl_data->value_bytes()/sizeofvalue;
   }



   static instance_type priv_get_instance_type(block_header_t *ctrl_data)
   {

      (((instance_type)ctrl_data->alloc_type() < max_allocation_type) ? static_cast<void> (0) : __assert_fail ("(instance_type)ctrl_data->alloc_type() < max_allocation_type", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 827, __PRETTY_FUNCTION__));
      return (instance_type)ctrl_data->alloc_type();
   }

   static size_type priv_get_reserved_bytes()
   {


      return sizeof(segment_manager) - sizeof(Base);
   }

   template <class CharT>
   void *priv_generic_find
      (const CharT* name,
       IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
       ipcdetail::in_place_interface &table,
       size_type &length,
       ipcdetail::true_ is_intrusive,
       bool use_lock)
   {
      (void)is_intrusive;
      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef ipcdetail::index_key<CharT, void_pointer> index_key_t;
      typedef typename index_type::iterator index_it;


      scoped_lock<rmutex> guard(priv_get_lock(use_lock));


      ipcdetail::intrusive_compare_key<CharT> key
         (name, std::char_traits<CharT>::length(name));
      index_it it = index.find(key);


      void *ret_ptr = 0;
      length = 0;


      if(it != index.end()){

         block_header_t *ctrl_data = it->get_block_header();


         (((ctrl_data->m_value_bytes % table.size) == 0) ? static_cast<void> (0) : __assert_fail ("(ctrl_data->m_value_bytes % table.size) == 0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 870, __PRETTY_FUNCTION__));
         ((ctrl_data->sizeof_char() == sizeof(CharT)) ? static_cast<void> (0) : __assert_fail ("ctrl_data->sizeof_char() == sizeof(CharT)", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 871, __PRETTY_FUNCTION__));
         ret_ptr = ctrl_data->value();
         length = ctrl_data->m_value_bytes/table.size;
      }
      return ret_ptr;
   }

   template <class CharT>
   void *priv_generic_find
      (const CharT* name,
       IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
       ipcdetail::in_place_interface &table,
       size_type &length,
       ipcdetail::false_ is_intrusive,
       bool use_lock)
   {
      (void)is_intrusive;
      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef typename index_type::key_type key_type;
      typedef typename index_type::iterator index_it;


      scoped_lock<rmutex> guard(priv_get_lock(use_lock));


      index_it it = index.find(key_type(name, std::char_traits<CharT>::length(name)));


      void *ret_ptr = 0;
      length = 0;


      if(it != index.end()){

         block_header_t *ctrl_data = reinterpret_cast<block_header_t*>
                                    (ipcdetail::to_raw_pointer(it->second.m_ptr));


         (((ctrl_data->m_value_bytes % table.size) == 0) ? static_cast<void> (0) : __assert_fail ("(ctrl_data->m_value_bytes % table.size) == 0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 909, __PRETTY_FUNCTION__));
         ((ctrl_data->sizeof_char() == sizeof(CharT)) ? static_cast<void> (0) : __assert_fail ("ctrl_data->sizeof_char() == sizeof(CharT)", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 910, __PRETTY_FUNCTION__));
         ret_ptr = ctrl_data->value();
         length = ctrl_data->m_value_bytes/table.size;
      }
      return ret_ptr;
   }

   template <class CharT>
   bool priv_generic_named_destroy
     (block_header_t *block_header,
      IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
      ipcdetail::in_place_interface &table,
      ipcdetail::true_ is_node_index)
   {
      (void)is_node_index;
      typedef typename IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >::iterator index_it;

      index_it *ihdr = block_header_t::template to_first_header<index_it>(block_header);
      return this->priv_generic_named_destroy_impl<CharT>(*ihdr, index, table);
   }

   template <class CharT>
   bool priv_generic_named_destroy
     (block_header_t *block_header,
      IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
      ipcdetail::in_place_interface &table,
      ipcdetail::false_ is_node_index)
   {
      (void)is_node_index;
      CharT *name = static_cast<CharT*>(block_header->template name<CharT>());
      return this->priv_generic_named_destroy<CharT>(name, index, table, is_intrusive_t());
   }

   template <class CharT>
   bool priv_generic_named_destroy(const CharT *name,
                                   IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
                                   ipcdetail::in_place_interface &table,
                                   ipcdetail::true_ is_intrusive_index)
   {
      (void)is_intrusive_index;
      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef ipcdetail::index_key<CharT, void_pointer> index_key_t;
      typedef typename index_type::iterator index_it;
      typedef typename index_type::value_type intrusive_value_type;


      scoped_lock<rmutex> guard(m_header);


      ipcdetail::intrusive_compare_key<CharT> key
         (name, std::char_traits<CharT>::length(name));
      index_it it = index.find(key);


      if(it == index.end()){


         return false;
      }

      block_header_t *ctrl_data = it->get_block_header();
      intrusive_value_type *iv = intrusive_value_type::get_intrusive_value_type(ctrl_data);
      void *memory = iv;
      void *values = ctrl_data->value();
      std::size_t num = ctrl_data->m_value_bytes/table.size;


      (((ctrl_data->m_value_bytes % table.size) == 0) ? static_cast<void> (0) : __assert_fail ("(ctrl_data->m_value_bytes % table.size) == 0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 977, __PRETTY_FUNCTION__));
      ((sizeof(CharT) == ctrl_data->sizeof_char()) ? static_cast<void> (0) : __assert_fail ("sizeof(CharT) == ctrl_data->sizeof_char()", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 978, __PRETTY_FUNCTION__));


      index.erase(it);


      ctrl_data->~block_header_t();
      iv->~intrusive_value_type();


      std::size_t destroyed;
      table.destroy_n(values, num, destroyed);
      this->deallocate(memory);
      return true;
   }

   template <class CharT>
   bool priv_generic_named_destroy(const CharT *name,
                                   IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
                                   ipcdetail::in_place_interface &table,
                                   ipcdetail::false_ is_intrusive_index)
   {
      (void)is_intrusive_index;
      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef typename index_type::iterator index_it;
      typedef typename index_type::key_type key_type;


      scoped_lock<rmutex> guard(m_header);


      index_it it = index.find(key_type (name,
                                     std::char_traits<CharT>::length(name)));


      if(it == index.end()){


         return false;
      }
      return this->priv_generic_named_destroy_impl<CharT>(it, index, table);
   }

   template <class CharT>
   bool priv_generic_named_destroy_impl
      (const typename IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> >::iterator &it,
      IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
      ipcdetail::in_place_interface &table)
   {
      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef typename index_type::iterator index_it;


      block_header_t *ctrl_data = reinterpret_cast<block_header_t*>
                                 (ipcdetail::to_raw_pointer(it->second.m_ptr));
      char *stored_name = static_cast<char*>(static_cast<void*>(const_cast<CharT*>(it->first.name())));
      (void)stored_name;



     std::size_t num = ctrl_data->m_value_bytes/table.size;
      void *values = ctrl_data->value();


      (((ctrl_data->m_value_bytes % table.size) == 0) ? static_cast<void> (0) : __assert_fail ("(ctrl_data->m_value_bytes % table.size) == 0", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 1042, __PRETTY_FUNCTION__));
      ((static_cast<void*>(stored_name) == static_cast<void*>(ctrl_data->template name<CharT>())) ? static_cast<void> (0) : __assert_fail ("static_cast<void*>(stored_name) == static_cast<void*>(ctrl_data->template name<CharT>())", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 1043, __PRETTY_FUNCTION__));
      ((sizeof(CharT) == ctrl_data->sizeof_char()) ? static_cast<void> (0) : __assert_fail ("sizeof(CharT) == ctrl_data->sizeof_char()", "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp", 1044, __PRETTY_FUNCTION__));


      index.erase(it);


      ctrl_data->~block_header_t();

      void *memory;
      if(is_node_index_t::value){
         index_it *ihdr = block_header_t::template
            to_first_header<index_it>(ctrl_data);
         ihdr->~index_it();
         memory = ihdr;
      }
      else{
         memory = ctrl_data;
      }


     std::size_t destroyed;
      table.destroy_n(values, num, destroyed);
      this->deallocate(memory);
      return true;
   }

   template<class CharT>
   void * priv_generic_named_construct(unsigned char type,
                               const CharT *name,
                        size_type num,
                               bool try2find,
                               bool dothrow,
                               ipcdetail::in_place_interface &table,
                               IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
                               ipcdetail::true_ is_intrusive)
   {
      (void)is_intrusive;
     std::size_t namelen = std::char_traits<CharT>::length(name);

      block_header_t block_info ( size_type(table.size*num)
                                 , size_type(table.alignment)
                                 , type
                                 , sizeof(CharT)
                                 , namelen);

      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef typename index_type::iterator index_it;
      typedef std::pair<index_it, bool> index_ib;


      scoped_lock<rmutex> guard(m_header);
# 1107 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
      index_ib insert_ret;

      typename index_type::insert_commit_data commit_data;
      typedef typename index_type::value_type intrusive_value_type;

      { try{
         ipcdetail::intrusive_compare_key<CharT> key(name, namelen);
         insert_ret = index.insert_check(key, commit_data);
      }

      catch(...){
         if(dothrow)
            throw;
         return 0;
      }
      }

      index_it it = insert_ret.first;



      if(!insert_ret.second){
         if(try2find){
            return it->get_block_header()->value();
         }
         if(dothrow){
            throw interprocess_exception(already_exists_error);
         }
         else{
            return 0;
         }
      }


      void *buffer_ptr;


      if(dothrow){
         buffer_ptr = this->allocate
            (block_info.template total_size_with_header<intrusive_value_type>());
      }
      else{
         buffer_ptr = this->allocate
            (block_info.template total_size_with_header<intrusive_value_type>(), std::nothrow_t());
         if(!buffer_ptr)
            return 0;
      }


      intrusive_value_type * intrusive_hdr = new(buffer_ptr) intrusive_value_type();
      block_header_t * hdr = new(intrusive_hdr->get_block_header())block_header_t(block_info);
      void *ptr = 0;
      ptr = hdr->value();


      CharT *name_ptr = static_cast<CharT *>(hdr->template name<CharT>());
      std::char_traits<CharT>::copy(name_ptr, name, namelen+1);

      { try{

         it = index.insert_commit(*intrusive_hdr, commit_data);
      }

      catch(...){
         if(dothrow)
            throw;
         return 0;
      }
      }



      ipcdetail::mem_algo_deallocator<segment_manager_base_type> mem
         (buffer_ptr, *static_cast<segment_manager_base_type*>(this));





      value_eraser<index_type> v_eraser(index, it);


      ipcdetail::array_construct(ptr, num, table);


      v_eraser.release();
      mem.release();
      return ptr;
   }



   template<class CharT>
   void * priv_generic_named_construct(unsigned char type,
                               const CharT *name,
                        size_type num,
                               bool try2find,
                               bool dothrow,
                               ipcdetail::in_place_interface &table,
                               IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > &index,
                               ipcdetail::false_ is_intrusive)
   {
      (void)is_intrusive;
      std::size_t namelen = std::char_traits<CharT>::length(name);

      block_header_t block_info ( size_type(table.size*num)
                                 , size_type(table.alignment)
                                 , type
                                 , sizeof(CharT)
                                 , namelen);

      typedef IndexType<ipcdetail::index_config<CharT, MemoryAlgorithm> > index_type;
      typedef typename index_type::key_type key_type;
      typedef typename index_type::mapped_type mapped_type;
      typedef typename index_type::value_type value_type;
      typedef typename index_type::iterator index_it;
      typedef std::pair<index_it, bool> index_ib;


      scoped_lock<rmutex> guard(m_header);
# 1239 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp"
      index_ib insert_ret;
      { try{
         insert_ret = index.insert(value_type(key_type (name, namelen), mapped_type(0)));
      }

      catch(...){
         if(dothrow)
            throw;;
         return 0;
      }
      }

      index_it it = insert_ret.first;



      if(!insert_ret.second){
         if(try2find){
            block_header_t *hdr = static_cast<block_header_t*>
               (ipcdetail::to_raw_pointer(it->second.m_ptr));
            return hdr->value();
         }
         return 0;
      }


      value_eraser<index_type> v_eraser(index, it);


      void *buffer_ptr;
      block_header_t * hdr;


      if(is_node_index_t::value){
         size_type total_size = block_info.template total_size_with_header<index_it>();
         if(dothrow){
            buffer_ptr = this->allocate(total_size);
         }
         else{
            buffer_ptr = this->allocate(total_size, std::nothrow_t());
            if(!buffer_ptr)
               return 0;
         }
         index_it *idr = new(buffer_ptr) index_it(it);
         hdr = block_header_t::template from_first_header<index_it>(idr);
      }
      else{
         if(dothrow){
            buffer_ptr = this->allocate(block_info.total_size());
         }
         else{
            buffer_ptr = this->allocate(block_info.total_size(), std::nothrow_t());
            if(!buffer_ptr)
               return 0;
         }
         hdr = static_cast<block_header_t*>(buffer_ptr);
      }

      hdr = new(hdr)block_header_t(block_info);
      void *ptr = 0;
      ptr = hdr->value();


      CharT *name_ptr = static_cast<CharT *>(hdr->template name<CharT>());
      std::char_traits<CharT>::copy(name_ptr, name, namelen+1);




      const_cast<key_type &>(it->first).name(name_ptr);
      it->second.m_ptr = hdr;


      ipcdetail::mem_algo_deallocator<segment_manager_base_type> mem
         (buffer_ptr, *static_cast<segment_manager_base_type*>(this));


      ipcdetail::array_construct(ptr, num, table);


      mem.release();


      v_eraser.release();
      return ptr;
   }

   private:

   segment_manager *get_this_pointer()
   { return this; }

   typedef typename MemoryAlgorithm::mutex_family::recursive_mutex_type rmutex;

   scoped_lock<rmutex> priv_get_lock(bool use_lock)
   {
      scoped_lock<rmutex> local(m_header, defer_lock);
      if(use_lock){
         local.lock();
      }
      return scoped_lock<rmutex>(boost::move(local));
   }



   struct header_t
      : public rmutex
   {
      named_index_t m_named_index;
      unique_index_t m_unique_index;

      header_t(Base *restricted_segment_mngr)
         : m_named_index (restricted_segment_mngr)
         , m_unique_index(restricted_segment_mngr)
      {}
   } m_header;


};


}}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 1363 "/opt/sevenflow/boost/include/boost/interprocess/segment_manager.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2





# 1 "/usr/include/c++/4.8.2/fstream" 1 3
# 36 "/usr/include/c++/4.8.2/fstream" 3
       
# 37 "/usr/include/c++/4.8.2/fstream" 3



# 1 "/usr/include/c++/4.8.2/bits/codecvt.h" 1 3
# 39 "/usr/include/c++/4.8.2/bits/codecvt.h" 3
       
# 40 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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&);




}
# 41 "/usr/include/c++/4.8.2/fstream" 2 3
# 1 "/usr/include/c++/4.8.2/cstdio" 1 3
# 39 "/usr/include/c++/4.8.2/cstdio" 3
       
# 40 "/usr/include/c++/4.8.2/cstdio" 3
# 42 "/usr/include/c++/4.8.2/fstream" 2 3
# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 1 3
# 37 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 3
       
# 38 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/basic_file.h" 3


# 1 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++io.h" 1 3
# 35 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++io.h" 3
# 1 "/usr/include/c++/4.8.2/cstdio" 1 3
# 39 "/usr/include/c++/4.8.2/cstdio" 3
       
# 40 "/usr/include/c++/4.8.2/cstdio" 3
# 36 "/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++io.h" 2 3


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


  typedef __gthread_mutex_t __c_lock;


  typedef FILE __c_file;


}
# 41 "/usr/include/c++/4.8.2/x86_64-redhat-linux/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.2/fstream" 2 3




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

# 71 "/usr/include/c++/4.8.2/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.2/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.2/fstream" 3
      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);
# 296 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/fstream" 3
      basic_ifstream() : __istream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 466 "/usr/include/c++/4.8.2/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.2/fstream" 3
      ~basic_ifstream()
      { }
# 508 "/usr/include/c++/4.8.2/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.2/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.2/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
# 598 "/usr/include/c++/4.8.2/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.2/fstream" 3
      basic_ofstream(): __ostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 639 "/usr/include/c++/4.8.2/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.2/fstream" 3
      ~basic_ofstream()
      { }
# 683 "/usr/include/c++/4.8.2/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.2/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.2/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };
# 775 "/usr/include/c++/4.8.2/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.2/fstream" 3
      basic_fstream()
      : __iostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 815 "/usr/include/c++/4.8.2/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.2/fstream" 3
      ~basic_fstream()
      { }
# 856 "/usr/include/c++/4.8.2/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.2/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.2/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
    };


}

# 1 "/usr/include/c++/4.8.2/bits/fstream.tcc" 1 3
# 37 "/usr/include/c++/4.8.2/bits/fstream.tcc" 3
       
# 38 "/usr/include/c++/4.8.2/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.2/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.2/fstream" 2 3
# 33 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2





namespace boost {
namespace interprocess {
namespace ipcdetail {

template<class BasicManagedMemoryImpl>
class create_open_func;

template<
         class CharType,
         class MemoryAlgorithm,
         template<class IndexConfig> class IndexType
        >
struct segment_manager_type
{
   typedef segment_manager<CharType, MemoryAlgorithm, IndexType> type;
};
# 64 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
template < class CharType
         , class MemoryAlgorithm
         , template<class IndexConfig> class IndexType
         , std::size_t Offset = 0
         >
class basic_managed_memory_impl
{

   basic_managed_memory_impl(const basic_managed_memory_impl &);
   basic_managed_memory_impl &operator=(const basic_managed_memory_impl &);

   template<class BasicManagedMemoryImpl>
   friend class create_open_func;

   public:
   typedef typename segment_manager_type
      <CharType, MemoryAlgorithm, IndexType>::type segment_manager;
   typedef CharType char_type;
   typedef MemoryAlgorithm memory_algorithm;
   typedef typename MemoryAlgorithm::mutex_family mutex_family;
   typedef CharType char_t;
   typedef typename MemoryAlgorithm::size_type size_type;
   typedef typename MemoryAlgorithm::difference_type difference_type;
   typedef difference_type handle_t;
   typedef typename segment_manager::
      const_named_iterator const_named_iterator;
   typedef typename segment_manager::
      const_unique_iterator const_unique_iterator;



   typedef typename
           segment_manager::char_ptr_holder_t char_ptr_holder_t;


   typedef typename segment_manager::multiallocation_chain multiallocation_chain;



   static const size_type PayloadPerAllocation = segment_manager::PayloadPerAllocation;

   private:
   typedef basic_managed_memory_impl
               <CharType, MemoryAlgorithm, IndexType, Offset> self_t;
   protected:
   template<class ManagedMemory>
   static bool grow(const char *filename, size_type extra_bytes)
   {
      typedef typename ManagedMemory::device_type device_type;

      try{
         offset_t old_size;
         {
            device_type f(open_or_create, filename, read_write);
            if(!f.get_size(old_size))
               return false;
            f.truncate(old_size + extra_bytes);
         }
         ManagedMemory managed_memory(open_only, filename);

         managed_memory.self_t::grow(extra_bytes);
      }
      catch(...){
         return false;
      }
      return true;
   }

   template<class ManagedMemory>
   static bool shrink_to_fit(const char *filename)
   {
      typedef typename ManagedMemory::device_type device_type;
      size_type new_size;
      try{
         ManagedMemory managed_memory(open_only, filename);
         managed_memory.get_size();
         managed_memory.self_t::shrink_to_fit();
         new_size = managed_memory.get_size();
      }
      catch(...){
         return false;
      }


      {
         device_type f(open_or_create, filename, read_write);
         f.truncate(new_size);
      }
      return true;
   }


   basic_managed_memory_impl()
      : mp_header(0){}


   ~basic_managed_memory_impl()
   { this->close_impl(); }


   bool create_impl (void *addr, size_type size)
   {
      if(mp_header) return false;


      if(size < segment_manager::get_min_size())
         return false;



      { try{

         mp_header = new(addr) segment_manager(size);
      }
      catch(...){
         return false;
      }
      }
      return true;
   }


   bool open_impl (void *addr, size_type)
   {
      if(mp_header) return false;
      mp_header = static_cast<segment_manager*>(addr);
      return true;
   }


   bool close_impl()
   {
      bool ret = mp_header != 0;
      mp_header = 0;
      return ret;
   }


   bool destroy_impl()
   {
      if(mp_header == 0)
         return false;
      mp_header->~segment_manager();
      this->close_impl();
         return true;
   }


   void grow(size_type extra_bytes)
   { mp_header->grow(extra_bytes); }

   void shrink_to_fit()
   { mp_header->shrink_to_fit(); }

   public:


   segment_manager *get_segment_manager() const
   { return mp_header; }


   void * get_address () const
   { return reinterpret_cast<char*>(mp_header) - Offset; }


   size_type get_size () const
   { return mp_header->get_size() + Offset; }



   size_type get_free_memory() const
   { return mp_header->get_free_memory(); }



   bool all_memory_deallocated()
   { return mp_header->all_memory_deallocated(); }



   bool check_sanity()
   { return mp_header->check_sanity(); }



   void zero_free_memory()
   { mp_header->zero_free_memory(); }



   handle_t get_handle_from_address (const void *ptr) const
   {
      return (handle_t)(reinterpret_cast<const char*>(ptr) -
             reinterpret_cast<const char*>(this->get_address()));
   }


   bool belongs_to_segment (const void *ptr) const
   {
      return ptr >= this->get_address() &&
             ptr < (reinterpret_cast<const char*>(this->get_address()) + this->get_size());
   }



   void * get_address_from_handle (handle_t offset) const
   { return reinterpret_cast<char*>(this->get_address()) + offset; }




   void* allocate (size_type nbytes)
   { return mp_header->allocate(nbytes); }




   void* allocate (size_type nbytes, std::nothrow_t nothrow)
   { return mp_header->allocate(nbytes, nothrow); }




   void * allocate_aligned (size_type nbytes, size_type alignment, std::nothrow_t nothrow)
   { return mp_header->allocate_aligned(nbytes, alignment, nothrow); }

   template<class T>
   std::pair<T *, bool>
      allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
                           size_type preferred_size,size_type &received_size,
                           T *reuse_ptr = 0)
   {
      return mp_header->allocation_command
         (command, limit_size, preferred_size, received_size, reuse_ptr);
   }




   void * allocate_aligned(size_type nbytes, size_type alignment)
   { return mp_header->allocate_aligned(nbytes, alignment); }






   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
   { return mp_header->allocate_many(elem_bytes, num_elements); }


   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements)
   { return mp_header->allocate_many(elem_sizes, n_elements); }


   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements, std::nothrow_t nothrow)
   { return mp_header->allocate_many(elem_bytes, num_elements, nothrow); }


   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements, std::nothrow_t nothrow)
   { return mp_header->allocate_many(elem_sizes, n_elements, nothrow); }


   void deallocate_many(multiallocation_chain chain)
   { return mp_header->deallocate_many(boost::move(chain)); }




   void deallocate (void *addr)
   { if (mp_header) mp_header->deallocate(addr); }




   template <class T>
   std::pair<T*, size_type> find (char_ptr_holder_t name)
   { return mp_header->template find<T>(name); }
# 359 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_proxy<T>::type
      construct(char_ptr_holder_t name)
   { return mp_header->template construct<T>(name); }
# 380 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_proxy<T>::type
      find_or_construct(char_ptr_holder_t name)
   { return mp_header->template find_or_construct<T>(name); }
# 401 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_proxy<T>::type
      construct(char_ptr_holder_t name, std::nothrow_t nothrow)
   { return mp_header->template construct<T>(name, nothrow); }
# 422 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_proxy<T>::type
      find_or_construct(char_ptr_holder_t name, std::nothrow_t nothrow)
   { return mp_header->template find_or_construct<T>(name, nothrow); }
# 443 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_iter_proxy<T>::type
      construct_it(char_ptr_holder_t name)
   { return mp_header->template construct_it<T>(name); }
# 466 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_iter_proxy<T>::type
      find_or_construct_it(char_ptr_holder_t name)
   { return mp_header->template find_or_construct_it<T>(name); }
# 487 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_iter_proxy<T>::type
      construct_it(char_ptr_holder_t name, std::nothrow_t nothrow)
   { return mp_header->template construct_it<T>(name, nothrow); }
# 510 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   typename segment_manager::template construct_iter_proxy<T>::type
      find_or_construct_it(char_ptr_holder_t name, std::nothrow_t nothrow)
   { return mp_header->template find_or_construct_it<T>(name, nothrow); }




   template <class Func>
   void atomic_func(Func &f)
   { mp_header->atomic_func(f); }






   template <class Func>
   bool try_atomic_func(Func &f)
   { return mp_header->try_atomic_func(f); }
# 561 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   bool destroy(const CharType *name)
   { return mp_header->template destroy<T>(name); }
# 581 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   bool destroy(const unique_instance_t *const )
   { return mp_header->template destroy<T>(unique_instance); }
# 601 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp"
   template <class T>
   void destroy_ptr(const T *ptr)
   { mp_header->template destroy_ptr<T>(ptr); }



   template<class T>
   static const char_type *get_instance_name(const T *ptr)
   { return segment_manager::get_instance_name(ptr); }



   template<class T>
   static instance_type get_instance_type(const T *ptr)
   { return segment_manager::get_instance_type(ptr); }



   template<class T>
   static size_type get_instance_length(const T *ptr)
   { return segment_manager::get_instance_length(ptr); }




   void reserve_named_objects(size_type num)
   { mp_header->reserve_named_objects(num); }




   void reserve_unique_objects(size_type num)
   { mp_header->reserve_unique_objects(num); }



   void shrink_to_fit_indexes()
   { mp_header->shrink_to_fit_indexes(); }



   size_type get_num_named_objects()
   { return mp_header->get_num_named_objects(); }



   size_type get_num_unique_objects()
   { return mp_header->get_num_unique_objects(); }



   const_named_iterator named_begin() const
   { return mp_header->named_begin(); }



   const_named_iterator named_end() const
   { return mp_header->named_end(); }



   const_unique_iterator unique_begin() const
   { return mp_header->unique_begin(); }



   const_unique_iterator unique_end() const
   { return mp_header->unique_end(); }



   template<class T>
   struct allocator
   {
      typedef typename segment_manager::template allocator<T>::type type;
   };



   template<class T>
   typename allocator<T>::type
      get_allocator()
   { return mp_header->template get_allocator<T>(); }



   template<class T>
   struct deleter
   {
      typedef typename segment_manager::template deleter<T>::type type;
   };



   template<class T>
   typename deleter<T>::type
      get_deleter()
   { return mp_header->template get_deleter<T>(); }





   template <class T>
   std::pair<T*, size_type> find_no_lock (char_ptr_holder_t name)
   { return mp_header->template find_no_lock<T>(name); }


   protected:


   void swap(basic_managed_memory_impl &other)
   { std::swap(mp_header, other.mp_header); }

   private:
   segment_manager *mp_header;
};

template<class BasicManagedMemoryImpl>
class create_open_func
{
   public:
   create_open_func(BasicManagedMemoryImpl * const frontend, create_enum_t type)
      : m_frontend(frontend), m_type(type){}

   bool operator()(void *addr, typename BasicManagedMemoryImpl::size_type size, bool created) const
   {
      if(((m_type == DoOpen) && created) ||
         ((m_type == DoCreate) && !created))
         return false;

      if(created)
         return m_frontend->create_impl(addr, size);
      else
         return m_frontend->open_impl (addr, size);
   }

   private:
   BasicManagedMemoryImpl *m_frontend;
   create_enum_t m_type;
};

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 748 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_memory_impl.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 39 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp" 2







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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 47 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 48 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp" 2


namespace boost { namespace interprocess {




template <class CharT, class CharTraits>
class basic_bufferbuf
   : public std::basic_streambuf<CharT, CharTraits>
{
   public:
   typedef CharT char_type;
   typedef typename CharTraits::int_type int_type;
   typedef typename CharTraits::pos_type pos_type;
   typedef typename CharTraits::off_type off_type;
   typedef CharTraits traits_type;
   typedef std::basic_streambuf<char_type, traits_type> base_t;

   public:


   explicit basic_bufferbuf(std::ios_base::openmode mode
                            = std::ios_base::in | std::ios_base::out)
      : base_t(), m_mode(mode), m_buffer(0), m_length(0)
      {}



   explicit basic_bufferbuf(CharT *buffer, std::size_t length,
                            std::ios_base::openmode mode
                              = std::ios_base::in | std::ios_base::out)
      : base_t(), m_mode(mode), m_buffer(buffer), m_length(length)
      { this->set_pointers(); }

   virtual ~basic_bufferbuf(){}

   public:


   std::pair<CharT *, std::size_t> buffer() const
      { return std::pair<CharT *, std::size_t>(m_buffer, m_length); }



   void buffer(CharT *buffer, std::size_t length)
      { m_buffer = buffer; m_length = length; this->set_pointers(); }


   private:
   void set_pointers()
   {

      if(m_mode & std::ios_base::in)
         this->setg(m_buffer, m_buffer, m_buffer + m_length);


      if(m_mode & std::ios_base::out)
         this->setp(m_buffer, m_buffer + m_length);
   }

   protected:
   virtual int_type underflow()
   {

      return this->gptr() != this->egptr() ?
         CharTraits::to_int_type(*this->gptr()) : CharTraits::eof();
   }

   virtual int_type pbackfail(int_type c = CharTraits::eof())
   {
      if(this->gptr() != this->eback()) {
         if(!CharTraits::eq_int_type(c, CharTraits::eof())) {
            if(CharTraits::eq(CharTraits::to_char_type(c), this->gptr()[-1])) {
               this->gbump(-1);
               return c;
            }
            else if(m_mode & std::ios_base::out) {
               this->gbump(-1);
               *this->gptr() = c;
               return c;
            }
            else
               return CharTraits::eof();
         }
         else {
            this->gbump(-1);
            return CharTraits::not_eof(c);
         }
      }
      else
         return CharTraits::eof();
   }

   virtual int_type overflow(int_type c = CharTraits::eof())
   {
      if(m_mode & std::ios_base::out) {
         if(!CharTraits::eq_int_type(c, CharTraits::eof())) {
# 156 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp"
               if(this->pptr() == this->epptr()) {

                  return CharTraits::eof();
               }
               else {
                  *this->pptr() = CharTraits::to_char_type(c);
                  this->pbump(1);
                  return c;
               }

         }
         else
            return CharTraits::not_eof(c);
      }
      else
         return CharTraits::eof();
   }

   virtual pos_type seekoff(off_type off, std::ios_base::seekdir dir,
                              std::ios_base::openmode mode
                                 = std::ios_base::in | std::ios_base::out)
   {
      bool in = false;
      bool out = false;

      const std::ios_base::openmode inout =
         std::ios_base::in | std::ios_base::out;

      if((mode & inout) == inout) {
         if(dir == std::ios_base::beg || dir == std::ios_base::end)
            in = out = true;
      }
      else if(mode & std::ios_base::in)
         in = true;
      else if(mode & std::ios_base::out)
         out = true;

      if(!in && !out)
         return pos_type(off_type(-1));
      else if((in && (!(m_mode & std::ios_base::in) || this->gptr() == 0)) ||
               (out && (!(m_mode & std::ios_base::out) || this->pptr() == 0)))
         return pos_type(off_type(-1));

      std::streamoff newoff;
      switch(dir) {
         case std::ios_base::beg:
            newoff = 0;
         break;
         case std::ios_base::end:
            newoff = static_cast<std::streamoff>(m_length);
         break;
         case std::ios_base::cur:
            newoff = in ? static_cast<std::streamoff>(this->gptr() - this->eback())
                        : static_cast<std::streamoff>(this->pptr() - this->pbase());
         break;
         default:
            return pos_type(off_type(-1));
      }

      off += newoff;

      if(in) {
         std::ptrdiff_t n = this->egptr() - this->eback();

         if(off < 0 || off > n)
            return pos_type(off_type(-1));
         else
            this->setg(this->eback(), this->eback() + off, this->eback() + n);
      }

      if(out) {
         std::ptrdiff_t n = this->epptr() - this->pbase();

         if(off < 0 || off > n)
            return pos_type(off_type(-1));
         else {
            this->setp(this->pbase(), this->pbase() + n);
            this->pbump(off);
         }
      }

      return pos_type(off);
   }

   virtual pos_type seekpos(pos_type pos, std::ios_base::openmode mode
                                 = std::ios_base::in | std::ios_base::out)
   { return seekoff(pos - pos_type(off_type(0)), std::ios_base::beg, mode); }

   private:
   std::ios_base::openmode m_mode;
   CharT * m_buffer;
   std::size_t m_length;

};



template <class CharT, class CharTraits>
class basic_ibufferstream
   : public std::basic_istream<CharT, CharTraits>
{
   public:
   typedef typename std::basic_ios
      <CharT, CharTraits>::char_type char_type;
   typedef typename std::basic_ios<char_type, CharTraits>::int_type int_type;
   typedef typename std::basic_ios<char_type, CharTraits>::pos_type pos_type;
   typedef typename std::basic_ios<char_type, CharTraits>::off_type off_type;
   typedef typename std::basic_ios<char_type, CharTraits>::traits_type traits_type;

   private:
   typedef std::basic_ios<char_type, CharTraits> basic_ios_t;
   typedef std::basic_istream<char_type, CharTraits> base_t;

   public:


   basic_ibufferstream(std::ios_base::openmode mode = std::ios_base::in)
      : basic_ios_t(), base_t(0), m_buf(mode | std::ios_base::in)
      { basic_ios_t::init(&m_buf); }



   basic_ibufferstream(const CharT *buffer, std::size_t length,
                          std::ios_base::openmode mode = std::ios_base::in)
      : basic_ios_t(), base_t(0),
         m_buf(const_cast<CharT*>(buffer), length, mode | std::ios_base::in)
      { basic_ios_t::init(&m_buf); }

   ~basic_ibufferstream(){};

   public:


   basic_bufferbuf<CharT, CharTraits>* rdbuf() const
      { return const_cast<basic_bufferbuf<CharT, CharTraits>*>(&m_buf); }



   std::pair<const CharT *, std::size_t> buffer() const
      { return m_buf.buffer(); }



   void buffer(const CharT *buffer, std::size_t length)
      { m_buf.buffer(const_cast<CharT*>(buffer), length); }


   private:
   basic_bufferbuf<CharT, CharTraits> m_buf;

};



template <class CharT, class CharTraits>
class basic_obufferstream
   : public std::basic_ostream<CharT, CharTraits>
{
   public:
   typedef typename std::basic_ios
      <CharT, CharTraits>::char_type char_type;
   typedef typename std::basic_ios<char_type, CharTraits>::int_type int_type;
   typedef typename std::basic_ios<char_type, CharTraits>::pos_type pos_type;
   typedef typename std::basic_ios<char_type, CharTraits>::off_type off_type;
   typedef typename std::basic_ios<char_type, CharTraits>::traits_type traits_type;


   private:
   typedef std::basic_ios<char_type, CharTraits> basic_ios_t;
   typedef std::basic_ostream<char_type, CharTraits> base_t;

   public:


   basic_obufferstream(std::ios_base::openmode mode = std::ios_base::out)
      : basic_ios_t(), base_t(0), m_buf(mode | std::ios_base::out)
      { basic_ios_t::init(&m_buf); }



   basic_obufferstream(CharT *buffer, std::size_t length,
                       std::ios_base::openmode mode = std::ios_base::out)
      : basic_ios_t(), base_t(0),
         m_buf(buffer, length, mode | std::ios_base::out)
      { basic_ios_t::init(&m_buf); }

   ~basic_obufferstream(){}

   public:


   basic_bufferbuf<CharT, CharTraits>* rdbuf() const
      { return const_cast<basic_bufferbuf<CharT, CharTraits>*>(&m_buf); }



   std::pair<CharT *, std::size_t> buffer() const
      { return m_buf.buffer(); }



   void buffer(CharT *buffer, std::size_t length)
      { m_buf.buffer(buffer, length); }


   private:
   basic_bufferbuf<CharT, CharTraits> m_buf;

};




template <class CharT, class CharTraits>
class basic_bufferstream
   : public std::basic_iostream<CharT, CharTraits>

{
   public:
   typedef typename std::basic_ios
      <CharT, CharTraits>::char_type char_type;
   typedef typename std::basic_ios<char_type, CharTraits>::int_type int_type;
   typedef typename std::basic_ios<char_type, CharTraits>::pos_type pos_type;
   typedef typename std::basic_ios<char_type, CharTraits>::off_type off_type;
   typedef typename std::basic_ios<char_type, CharTraits>::traits_type traits_type;


   private:
   typedef std::basic_ios<char_type, CharTraits> basic_ios_t;
   typedef std::basic_iostream<char_type, CharTraits> base_t;


   public:


   basic_bufferstream(std::ios_base::openmode mode
                      = std::ios_base::in | std::ios_base::out)
      : basic_ios_t(), base_t(0), m_buf(mode)
      { basic_ios_t::init(&m_buf); }



   basic_bufferstream(CharT *buffer, std::size_t length,
                      std::ios_base::openmode mode
                        = std::ios_base::in | std::ios_base::out)
      : basic_ios_t(), base_t(0), m_buf(buffer, length, mode)
      { basic_ios_t::init(&m_buf); }

   ~basic_bufferstream(){}

   public:


   basic_bufferbuf<CharT, CharTraits>* rdbuf() const
      { return const_cast<basic_bufferbuf<CharT, CharTraits>*>(&m_buf); }



   std::pair<CharT *, std::size_t> buffer() const
      { return m_buf.buffer(); }



   void buffer(CharT *buffer, std::size_t length)
      { m_buf.buffer(buffer, length); }


   private:
   basic_bufferbuf<CharT, CharTraits> m_buf;

};


typedef basic_bufferbuf<char> bufferbuf;
typedef basic_bufferstream<char> bufferstream;
typedef basic_ibufferstream<char> ibufferstream;
typedef basic_obufferstream<char> obufferstream;

typedef basic_bufferbuf<wchar_t> wbufferbuf;
typedef basic_bufferstream<wchar_t> wbufferstream;
typedef basic_ibufferstream<wchar_t> wibufferstream;
typedef basic_obufferstream<wchar_t> wobufferstream;


}}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 443 "/opt/sevenflow/boost/include/boost/interprocess/streams/bufferstream.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp"
namespace boost {
namespace interprocess {
namespace ipcdetail{
# 103 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp"
typedef pthread_t OS_thread_id_t;
typedef pid_t OS_process_id_t;

struct OS_systemwide_thread_id_t
{
   OS_systemwide_thread_id_t()
      : pid(), tid()
   {}

   OS_systemwide_thread_id_t(pid_t p, pthread_t t)
      : pid(p), tid(t)
   {}

   OS_systemwide_thread_id_t(const OS_systemwide_thread_id_t &x)
      : pid(x.pid), tid(x.tid)
   {}

   OS_systemwide_thread_id_t(const volatile OS_systemwide_thread_id_t &x)
      : pid(x.pid), tid(x.tid)
   {}

   OS_systemwide_thread_id_t & operator=(const OS_systemwide_thread_id_t &x)
   { pid = x.pid; tid = x.tid; return *this; }

   OS_systemwide_thread_id_t & operator=(const volatile OS_systemwide_thread_id_t &x)
   { pid = x.pid; tid = x.tid; return *this; }

   void operator=(const OS_systemwide_thread_id_t &x) volatile
   { pid = x.pid; tid = x.tid; }

   pid_t pid;
   pthread_t tid;
};

inline void systemwide_thread_id_copy
   (const volatile OS_systemwide_thread_id_t &from, volatile OS_systemwide_thread_id_t &to)
{
   to.pid = from.pid;
   to.tid = from.tid;
}


inline OS_process_id_t get_current_process_id()
{ return ::getpid(); }

inline OS_process_id_t get_invalid_process_id()
{ return pid_t(0); }


inline OS_thread_id_t get_current_thread_id()
{ return ::pthread_self(); }

inline OS_thread_id_t get_invalid_thread_id()
{
   static pthread_t invalid_id;
   return invalid_id;
}

inline bool equal_thread_id(OS_thread_id_t id1, OS_thread_id_t id2)
{ return 0 != pthread_equal(id1, id2); }

inline void thread_yield()
{ ::sched_yield(); }

inline void thread_sleep(unsigned int ms)
{
   const struct timespec rqt = { ms/1000u, (ms%1000u)*1000000u };
   ::nanosleep(&rqt, 0);
}


inline OS_systemwide_thread_id_t get_current_systemwide_thread_id()
{
   return OS_systemwide_thread_id_t(::getpid(), ::pthread_self());
}

inline bool equal_systemwide_thread_id(const OS_systemwide_thread_id_t &id1, const OS_systemwide_thread_id_t &id2)
{
   return (0 != pthread_equal(id1.tid, id2.tid)) && (id1.pid == id2.pid);
}

inline OS_systemwide_thread_id_t get_invalid_systemwide_thread_id()
{
   return OS_systemwide_thread_id_t(get_invalid_process_id(), get_invalid_thread_id());
}

inline long double get_current_process_creation_time()
{ return 0.0L; }



typedef char pid_str_t[sizeof(OS_process_id_t)*3+1];

inline void get_pid_str(pid_str_t &pid_str, OS_process_id_t pid)
{
   bufferstream bstream(pid_str, sizeof(pid_str));
   bstream << pid << std::ends;
}

inline void get_pid_str(pid_str_t &pid_str)
{ get_pid_str(pid_str, get_current_process_id()); }

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 210 "/opt/sevenflow/boost/include/boost/interprocess/detail/os_thread_functions.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp"
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 2







# 1 "/usr/include/sys/mman.h" 1 3 4
# 25 "/usr/include/sys/mman.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 26 "/usr/include/sys/mman.h" 2 3 4
# 41 "/usr/include/sys/mman.h" 3 4
# 1 "/usr/include/bits/mman.h" 1 3 4
# 42 "/usr/include/sys/mman.h" 2 3 4




extern "C" {
# 57 "/usr/include/sys/mman.h" 3 4
extern void *mmap (void *__addr, size_t __len, int __prot,
     int __flags, int __fd, __off_t __offset) throw ();
# 70 "/usr/include/sys/mman.h" 3 4
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/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);

}
# 32 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 2




# 1 "/usr/include/sys/shm.h" 1 3 4
# 24 "/usr/include/sys/shm.h" 3 4
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 25 "/usr/include/sys/shm.h" 2 3 4


# 1 "/usr/include/sys/ipc.h" 1 3 4
# 28 "/usr/include/sys/ipc.h" 3 4
# 1 "/usr/include/bits/ipctypes.h" 1 3 4
# 28 "/usr/include/bits/ipctypes.h" 3 4
typedef int __ipc_pid_t;
# 29 "/usr/include/sys/ipc.h" 2 3 4
# 1 "/usr/include/bits/ipc.h" 1 3 4
# 42 "/usr/include/bits/ipc.h" 3 4
struct ipc_perm
  {
    __key_t __key;
    __uid_t uid;
    __gid_t gid;
    __uid_t cuid;
    __gid_t cgid;
    unsigned short int mode;
    unsigned short int __pad1;
    unsigned short int __seq;
    unsigned short int __pad2;
    __syscall_ulong_t __unused1;
    __syscall_ulong_t __unused2;
  };
# 30 "/usr/include/sys/ipc.h" 2 3 4
# 51 "/usr/include/sys/ipc.h" 3 4
extern "C" {


extern key_t ftok (const char *__pathname, int __proj_id) throw ();

}
# 28 "/usr/include/sys/shm.h" 2 3 4


# 1 "/usr/include/bits/shm.h" 1 3 4
# 38 "/usr/include/bits/shm.h" 3 4
extern "C" {



extern int __getpagesize (void) throw () __attribute__ ((__const__));



typedef __syscall_ulong_t shmatt_t;


struct shmid_ds
  {
    struct ipc_perm shm_perm;
    size_t shm_segsz;
    __time_t shm_atime;



    __time_t shm_dtime;



    __time_t shm_ctime;



    __pid_t shm_cpid;
    __pid_t shm_lpid;
    shmatt_t shm_nattch;
    __syscall_ulong_t __unused4;
    __syscall_ulong_t __unused5;
  };
# 84 "/usr/include/bits/shm.h" 3 4
struct shminfo
  {
    __syscall_ulong_t shmmax;
    __syscall_ulong_t shmmin;
    __syscall_ulong_t shmmni;
    __syscall_ulong_t shmseg;
    __syscall_ulong_t shmall;
    __syscall_ulong_t __unused1;
    __syscall_ulong_t __unused2;
    __syscall_ulong_t __unused3;
    __syscall_ulong_t __unused4;
  };

struct shm_info
  {
    int used_ids;
    __syscall_ulong_t shm_tot;
    __syscall_ulong_t shm_rss;
    __syscall_ulong_t shm_swp;
    __syscall_ulong_t swap_attempts;
    __syscall_ulong_t swap_successes;
  };



}
# 31 "/usr/include/sys/shm.h" 2 3 4
# 44 "/usr/include/sys/shm.h" 3 4
extern "C" {





extern int shmctl (int __shmid, int __cmd, struct shmid_ds *__buf) throw ();


extern int shmget (key_t __key, size_t __size, int __shmflg) throw ();


extern void *shmat (int __shmid, const void *__shmaddr, int __shmflg)
     throw ();


extern int shmdt (const void *__shmaddr) throw ();

}
# 37 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 39 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 2
# 48 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp"
namespace boost {
namespace interprocess {


namespace ipcdetail{ class interprocess_tester; }
namespace ipcdetail{ class raw_mapped_region_creator; }
# 63 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp"
class mapped_region
{


   private: mapped_region(mapped_region &); mapped_region& operator=(mapped_region &); public: operator ::boost::rv<mapped_region>&() { return *static_cast< ::boost::rv<mapped_region>* >(this); } operator const ::boost::rv<mapped_region>&() const { return *static_cast<const ::boost::rv<mapped_region>* >(this); } private:


   public:
# 82 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp"
   template<class MemoryMappable>
   mapped_region(const MemoryMappable& mapping
                ,mode_t mode
                ,offset_t offset = 0
                ,std::size_t size = 0
                ,const void *address = 0);




   mapped_region();



   mapped_region(::boost::rv< mapped_region >& other)






   : m_base(0), m_size(0), m_page_offset(0), m_mode(read_only), m_is_xsi(false)

   { this->swap(other); }



   ~mapped_region();



   mapped_region &operator=(::boost::rv< mapped_region >& other)
   {
      mapped_region tmp(boost::move(other));
      this->swap(tmp);
      return *this;
   }


   std::size_t get_size() const;



   void* get_address() const;



   mode_t get_mode() const;






   bool flush(std::size_t mapping_offset = 0, std::size_t numbytes = 0, bool async = true);



   void swap(mapped_region &other);




   static std::size_t get_page_size();


   private:

   void priv_close();

   void* priv_map_address() const;
   std::size_t priv_map_size() const;
   bool priv_flush_param_check(std::size_t mapping_offset, void *&addr, std::size_t &numbytes) const;
   static void priv_size_from_mapping_size
      (offset_t mapping_size, offset_t offset, offset_t page_offset, std::size_t &size);
   static offset_t priv_page_offset_addr_fixup(offset_t page_offset, const void *&addr);

   template<int dummy>
   struct page_size_holder
   {
      static const std::size_t PageSize;
      static std::size_t get_page_size();
   };

   void* m_base;
   std::size_t m_size;
   std::size_t m_page_offset;
   mode_t m_mode;



   bool m_is_xsi;


   friend class ipcdetail::interprocess_tester;
   friend class ipcdetail::raw_mapped_region_creator;
   void dont_close_on_destruction();





};



inline void swap(mapped_region &x, mapped_region &y)
{ x.swap(y); }

inline mapped_region::~mapped_region()
{ this->priv_close(); }

inline std::size_t mapped_region::get_size() const
{ return m_size; }

inline mode_t mapped_region::get_mode() const
{ return m_mode; }

inline void* mapped_region::get_address() const
{ return m_base; }

inline void* mapped_region::priv_map_address() const
{ return static_cast<char*>(m_base) - m_page_offset; }

inline std::size_t mapped_region::priv_map_size() const
{ return m_size + m_page_offset; }

inline bool mapped_region::priv_flush_param_check
   (std::size_t mapping_offset, void *&addr, std::size_t &numbytes) const
{

   if(m_base == 0)
      return false;

   if(mapping_offset >= m_size || (mapping_offset + numbytes) > m_size){
      return false;
   }


   if(numbytes == 0){
      numbytes = m_size - mapping_offset;
   }
   addr = (char*)this->priv_map_address() + mapping_offset;
   numbytes += m_page_offset;
   return true;
}

inline void mapped_region::priv_size_from_mapping_size
   (offset_t mapping_size, offset_t offset, offset_t page_offset, std::size_t &size)
{


   if(mapping_size < offset ||
      boost::uintmax_t(mapping_size - (offset - page_offset)) >
         boost::uintmax_t(std::size_t(-1))){
      error_info err(size_error);
      throw interprocess_exception(err);
   }
   size = static_cast<std::size_t>(mapping_size - (offset - page_offset));
}

inline offset_t mapped_region::priv_page_offset_addr_fixup(offset_t offset, const void *&address)
{


   const std::size_t page_size = mapped_region::get_page_size();



   const std::size_t page_offset =
      static_cast<std::size_t>(offset - (offset / page_size) * page_size);

   if(address){
      address = static_cast<const char*>(address) - page_offset;
   }
   return page_offset;
}
# 429 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp"
inline mapped_region::mapped_region()
   : m_base(0), m_size(0), m_page_offset(0), m_mode(read_only), m_is_xsi(false)
{}

template<int dummy>
inline std::size_t mapped_region::page_size_holder<dummy>::get_page_size()
{ return std::size_t(sysconf(_SC_PAGESIZE)); }

template<class MemoryMappable>
inline mapped_region::mapped_region
   ( const MemoryMappable &mapping
   , mode_t mode
   , offset_t offset
   , std::size_t size
   , const void *address)
   : m_base(0), m_size(0), m_page_offset(0), m_mode(mode), m_is_xsi(false)
{
   mapping_handle_t map_hnd = mapping.get_mapping_handle();



   if(map_hnd.is_xsi){

      ::shmid_ds xsi_ds;
      int ret = ::shmctl(map_hnd.handle, 2, &xsi_ds);
      if(ret == -1){
         error_info err(system_error_code());
         throw interprocess_exception(err);
      }

      if(size == 0){
         size = (std::size_t)xsi_ds.shm_segsz;
      }
      else if(size != (std::size_t)xsi_ds.shm_segsz){
         error_info err(size_error);
         throw interprocess_exception(err);
      }

      int flag = 0;
      if(m_mode == read_only){
         flag |= 010000;
      }
      else if(m_mode != read_write){
         error_info err(mode_error);
         throw interprocess_exception(err);
      }

      void *base = ::shmat(map_hnd.handle, (void*)address, flag);
      if(base == (void*)-1){
         error_info err(system_error_code());
         throw interprocess_exception(err);
      }

      m_base = base;
      m_size = size;
      m_mode = mode;
      m_page_offset = 0;
      m_is_xsi = true;
      return;
   }



   const offset_t page_offset = priv_page_offset_addr_fixup(offset, address);

   if(size == 0){
      struct ::stat buf;
      if(0 != fstat(map_hnd.handle, &buf)){
         error_info err(system_error_code());
         throw interprocess_exception(err);
      }

      priv_size_from_mapping_size(buf.st_size, offset, page_offset, size);
   }


   int prot = 0;
   int flags = 0;

   switch(mode)
   {
      case read_only:
         prot |= 0x1;
         flags |= 0x01;
      break;

      case read_private:
         prot |= (0x1);
         flags |= 0x02;
      break;

      case read_write:
         prot |= (0x2 | 0x1);
         flags |= 0x01;
      break;

      case copy_on_write:
         prot |= (0x2 | 0x1);
         flags |= 0x02;
      break;

      default:
         {
            error_info err(mode_error);
            throw interprocess_exception(err);
         }
      break;
   }


   void* base = mmap ( const_cast<void*>(address)
                     , static_cast<std::size_t>(page_offset + size)
                     , prot
                     , flags
                     , mapping.get_mapping_handle().handle
                     , offset - page_offset);


   if(base == ((void *) -1)){
      error_info err = system_error_code();
      throw interprocess_exception(err);
   }


   m_base = static_cast<char*>(base) + page_offset;
   m_page_offset = page_offset;
   m_size = size;


   if(address && (base != address)){
      error_info err(busy_error);
      this->priv_close();
      throw interprocess_exception(err);
   }
}

inline bool mapped_region::flush(std::size_t mapping_offset, std::size_t numbytes, bool async)
{
   void *addr;
   if(!this->priv_flush_param_check(mapping_offset, addr, numbytes)){
      return false;
   }

   return msync( addr, numbytes, async ? 1 : 4) == 0;
}

inline void mapped_region::priv_close()
{
   if(m_base != 0){

      if(m_is_xsi){
         int ret = ::shmdt(m_base);
         ((ret == 0) ? static_cast<void> (0) : __assert_fail ("ret == 0", "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp", 581, __PRETTY_FUNCTION__));
         (void)ret;
         return;
      }

      munmap(this->priv_map_address(), this->priv_map_size());
      m_base = 0;
   }
}

inline void mapped_region::dont_close_on_destruction()
{ m_base = 0; }



template<int dummy>
const std::size_t mapped_region::page_size_holder<dummy>::PageSize
   = mapped_region::page_size_holder<dummy>::get_page_size();

inline std::size_t mapped_region::get_page_size()
{
   if(!page_size_holder<0>::PageSize)
      return page_size_holder<0>::get_page_size();
   else
      return page_size_holder<0>::PageSize;
}

inline void mapped_region::swap(mapped_region &other)
{
   ipcdetail::do_swap(this->m_base, other.m_base);
   ipcdetail::do_swap(this->m_size, other.m_size);
   ipcdetail::do_swap(this->m_page_offset, other.m_page_offset);
   ipcdetail::do_swap(this->m_mode, other.m_mode);



   ipcdetail::do_swap(this->m_is_xsi, other.m_is_xsi);

}


struct null_mapped_region_function
{
   bool operator()(void *, std::size_t , bool) const
      { return true; }
};



}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 634 "/opt/sevenflow/boost/include/boost/interprocess/mapped_region.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp" 2

namespace boost{
namespace interprocess{
namespace ipcdetail{




inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem);


inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem);




inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val);







inline boost::uint32_t atomic_cas32
   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp);

}
}
}
# 98 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp"
namespace boost {
namespace interprocess {
namespace ipcdetail{







inline boost::uint32_t atomic_cas32
   (volatile boost::uint32_t *mem, boost::uint32_t with, boost::uint32_t cmp)
{
   boost::uint32_t prev = cmp;

   __asm__ __volatile__ ( "lock\n\t"
                          "cmpxchg %2,%0"
                        : "+m"(*mem), "+a"(prev)
                        : "r"(with)
                        : "cc");

   return prev;
}





inline boost::uint32_t atomic_add32
   (volatile boost::uint32_t *mem, boost::uint32_t val)
{



   int r;

   asm volatile
   (
      "lock\n\t"
      "xadd %1, %0":
      "+m"( *mem ), "=r"( r ):
      "1"( val ):
      "memory", "cc"
   );

   return r;
}




inline boost::uint32_t atomic_inc32(volatile boost::uint32_t *mem)
{ return atomic_add32(mem, 1); }




inline boost::uint32_t atomic_dec32(volatile boost::uint32_t *mem)
{ return atomic_add32(mem, (boost::uint32_t)-1); }


inline boost::uint32_t atomic_read32(volatile boost::uint32_t *mem)
{ return *mem; }




inline void atomic_write32(volatile boost::uint32_t *mem, boost::uint32_t val)
{ *mem = val; }

}
}
}
# 541 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp"
namespace boost{
namespace interprocess{
namespace ipcdetail{

inline bool atomic_add_unless32
   (volatile boost::uint32_t *mem, boost::uint32_t value, boost::uint32_t unless_this)
{
   boost::uint32_t old, c(atomic_read32(mem));
   while(c != unless_this && (old = atomic_cas32(mem, c + value, c)) != c){
      c = old;
   }
   return c != unless_this;
}

}
}
}


# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 561 "/opt/sevenflow/boost/include/boost/interprocess/detail/atomic.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/interprocess_tester.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/interprocess_tester.hpp"
namespace boost{
namespace interprocess{
namespace ipcdetail{

class interprocess_tester
{
   public:
   template<class T>
   static void dont_close_on_destruction(T &t)
   { t.dont_close_on_destruction(); }
};

}
}
}
# 23 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 30 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2

namespace boost {
namespace interprocess {


namespace ipcdetail{ class interprocess_tester; }


template<class DeviceAbstraction>
struct managed_open_or_create_impl_device_id_t
{
   typedef const char *type;
};



class xsi_shared_memory_file_wrapper;
class xsi_key;

template<>
struct managed_open_or_create_impl_device_id_t<xsi_shared_memory_file_wrapper>
{
   typedef xsi_key type;
};





namespace ipcdetail {


template <bool StoreDevice, class DeviceAbstraction>
class managed_open_or_create_impl_device_holder
{
   public:
   DeviceAbstraction &get_device()
   { static DeviceAbstraction dev; return dev; }

   const DeviceAbstraction &get_device() const
   { static DeviceAbstraction dev; return dev; }
};

template <class DeviceAbstraction>
class managed_open_or_create_impl_device_holder<true, DeviceAbstraction>
{
   public:
   DeviceAbstraction &get_device()
   { return dev; }

   const DeviceAbstraction &get_device() const
   { return dev; }

   private:
   DeviceAbstraction dev;
};

template<class DeviceAbstraction, std::size_t MemAlignment = 0, bool FileBased = true, bool StoreDevice = true>
class managed_open_or_create_impl
   : public managed_open_or_create_impl_device_holder<StoreDevice, DeviceAbstraction>
{

   private: managed_open_or_create_impl(managed_open_or_create_impl &); managed_open_or_create_impl& operator=(managed_open_or_create_impl &); public: operator ::boost::rv<managed_open_or_create_impl>&() { return *static_cast< ::boost::rv<managed_open_or_create_impl>* >(this); } operator const ::boost::rv<managed_open_or_create_impl>&() const { return *static_cast<const ::boost::rv<managed_open_or_create_impl>* >(this); } private:

   typedef typename managed_open_or_create_impl_device_id_t<DeviceAbstraction>::type device_id_t;
   typedef managed_open_or_create_impl_device_holder<StoreDevice, DeviceAbstraction> DevHolder;
   enum
   {
      UninitializedSegment,
      InitializingSegment,
      InitializedSegment,
      CorruptedSegment
   };

   public:
   static const std::size_t
      ManagedOpenOrCreateUserOffset =
         ct_rounded_size
            < sizeof(boost::uint32_t)
            , MemAlignment ? (MemAlignment) :
               (::boost::alignment_of< ::boost::detail::max_align >::value)
            >::value;

   managed_open_or_create_impl()
   {}

   managed_open_or_create_impl(create_only_t,
                 const device_id_t & id,
                 std::size_t size,
                 mode_t mode,
                 const void *addr,
                 const permissions &perm)
   {
      priv_open_or_create
         ( DoCreate
         , id
         , size
         , mode
         , addr
         , perm
         , null_mapped_region_function());
   }

   managed_open_or_create_impl(open_only_t,
                 const device_id_t & id,
                 mode_t mode,
                 const void *addr)
   {
      priv_open_or_create
         ( DoOpen
         , id
         , 0
         , mode
         , addr
         , permissions()
         , null_mapped_region_function());
   }


   managed_open_or_create_impl(open_or_create_t,
                 const device_id_t & id,
                 std::size_t size,
                 mode_t mode,
                 const void *addr,
                 const permissions &perm)
   {
      priv_open_or_create
         ( DoOpenOrCreate
         , id
         , size
         , mode
         , addr
         , perm
         , null_mapped_region_function());
   }

   template <class ConstructFunc>
   managed_open_or_create_impl(create_only_t,
                 const device_id_t & id,
                 std::size_t size,
                 mode_t mode,
                 const void *addr,
                 const ConstructFunc &construct_func,
                 const permissions &perm)
   {
      priv_open_or_create
         (DoCreate
         , id
         , size
         , mode
         , addr
         , perm
         , construct_func);
   }

   template <class ConstructFunc>
   managed_open_or_create_impl(open_only_t,
                 const device_id_t & id,
                 mode_t mode,
                 const void *addr,
                 const ConstructFunc &construct_func)
   {
      priv_open_or_create
         ( DoOpen
         , id
         , 0
         , mode
         , addr
         , permissions()
         , construct_func);
   }

   template <class ConstructFunc>
   managed_open_or_create_impl(open_or_create_t,
                 const device_id_t & id,
                 std::size_t size,
                 mode_t mode,
                 const void *addr,
                 const ConstructFunc &construct_func,
                 const permissions &perm)
   {
      priv_open_or_create
         ( DoOpenOrCreate
         , id
         , size
         , mode
         , addr
         , perm
         , construct_func);
   }

   managed_open_or_create_impl(::boost::rv< managed_open_or_create_impl >& moved)
   { this->swap(moved); }

   managed_open_or_create_impl &operator=(::boost::rv< managed_open_or_create_impl >& moved)
   {
      managed_open_or_create_impl tmp(boost::move(moved));
      this->swap(tmp);
      return *this;
   }

   ~managed_open_or_create_impl()
   {}

   std::size_t get_user_size() const
   { return m_mapped_region.get_size() - ManagedOpenOrCreateUserOffset; }

   void *get_user_address() const
   { return static_cast<char*>(m_mapped_region.get_address()) + ManagedOpenOrCreateUserOffset; }

   std::size_t get_real_size() const
   { return m_mapped_region.get_size(); }

   void *get_real_address() const
   { return m_mapped_region.get_address(); }

   void swap(managed_open_or_create_impl &other)
   {
      this->m_mapped_region.swap(other.m_mapped_region);
   }

   bool flush()
   { return m_mapped_region.flush(); }

   const mapped_region &get_mapped_region() const
   { return m_mapped_region; }


   DeviceAbstraction &get_device()
   { return this->DevHolder::get_device(); }

   const DeviceAbstraction &get_device() const
   { return this->DevHolder::get_device(); }

   private:


   template<bool dummy>
   static void truncate_device(DeviceAbstraction &, offset_t, false_)
   {}

   template<bool dummy>
   static void truncate_device(DeviceAbstraction &dev, offset_t size, true_)
   { dev.truncate(size); }


   template<bool dummy>
   static bool check_offset_t_size(std::size_t , false_)
   { return true; }

   template<bool dummy>
   static bool check_offset_t_size(std::size_t size, true_)
   { return size == std::size_t(offset_t(size)); }


   template<bool dummy>
   static void create_device(DeviceAbstraction &dev, const device_id_t & id, std::size_t size, const permissions &perm, false_ file_like)
   {
      (void)file_like;
      DeviceAbstraction tmp(create_only, id, read_write, size, perm);
      tmp.swap(dev);
   }

   template<bool dummy>
   static void create_device(DeviceAbstraction &dev, const device_id_t & id, std::size_t, const permissions &perm, true_ file_like)
   {
      (void)file_like;
      DeviceAbstraction tmp(create_only, id, read_write, perm);
      tmp.swap(dev);
   }

   template <class ConstructFunc> inline
   void priv_open_or_create
      (create_enum_t type,
       const device_id_t & id,
       std::size_t size,
       mode_t mode, const void *addr,
       const permissions &perm,
       ConstructFunc construct_func)
   {
      typedef bool_<FileBased> file_like_t;
      (void)mode;
      error_info err;
      bool created = false;
      bool ronly = false;
      bool cow = false;
      DeviceAbstraction dev;

      if(type != DoOpen && size < ManagedOpenOrCreateUserOffset){
         throw interprocess_exception(error_info(size_error));
      }

      if(type != DoOpen && !check_offset_t_size<FileBased>(size, file_like_t())){
         throw interprocess_exception(error_info(size_error));
      }
      if(type == DoOpen && mode == read_write){
         DeviceAbstraction tmp(open_only, id, read_write);
         tmp.swap(dev);
         created = false;
      }
      else if(type == DoOpen && mode == read_only){
         DeviceAbstraction tmp(open_only, id, read_only);
         tmp.swap(dev);
         created = false;
         ronly = true;
      }
      else if(type == DoOpen && mode == copy_on_write){
         DeviceAbstraction tmp(open_only, id, read_only);
         tmp.swap(dev);
         created = false;
         cow = true;
      }
      else if(type == DoCreate){
         create_device<FileBased>(dev, id, size, perm, file_like_t());
         created = true;
      }
      else if(type == DoOpenOrCreate){




         bool completed = false;
         while(!completed){
            try{
               create_device<FileBased>(dev, id, size, perm, file_like_t());
               created = true;
               completed = true;
            }
            catch(interprocess_exception &ex){
               if(ex.get_error_code() != already_exists_error){
                  throw;
               }
               else{
                  try{
                     DeviceAbstraction tmp(open_only, id, read_write);
                     dev.swap(tmp);
                     created = false;
                     completed = true;
                  }
                  catch(interprocess_exception &ex){
                     if(ex.get_error_code() != not_found_error){
                        throw;
                     }
                  }
                  catch(...){
                     throw;
                  }
               }
            }
            catch(...){
               throw;
            }
            thread_yield();
         }
      }

      if(created){
         try{

            truncate_device<FileBased>(dev, size, file_like_t());


            mapped_region region(dev, read_write, 0, 0, addr);
            boost::uint32_t *patomic_word = 0;
            patomic_word = static_cast<boost::uint32_t*>(region.get_address());
            boost::uint32_t previous = atomic_cas32(patomic_word, InitializingSegment, UninitializedSegment);

            if(previous == UninitializedSegment){
               try{
                  construct_func( static_cast<char*>(region.get_address()) + ManagedOpenOrCreateUserOffset
                                , size - ManagedOpenOrCreateUserOffset, true);

                  m_mapped_region.swap(region);
               }
               catch(...){
                  atomic_write32(patomic_word, CorruptedSegment);
                  throw;
               }
               atomic_write32(patomic_word, InitializedSegment);
            }
            else if(previous == InitializingSegment || previous == InitializedSegment){
               throw interprocess_exception(error_info(already_exists_error));
            }
            else{
               throw interprocess_exception(error_info(corrupted_error));
            }
         }
         catch(...){
            try{
               truncate_device<FileBased>(dev, 1u, file_like_t());
            }
            catch(...){
            }
            throw;
         }
      }
      else{
         if(FileBased){
            offset_t filesize = 0;
            while(filesize == 0){
               if(!get_file_size(file_handle_from_mapping_handle(dev.get_mapping_handle()), filesize)){
                  throw interprocess_exception(error_info(system_error_code()));
               }
               thread_yield();
            }
            if(filesize == 1){
               throw interprocess_exception(error_info(corrupted_error));
            }
         }

         mapped_region region(dev, ronly ? read_only : (cow ? copy_on_write : read_write), 0, 0, addr);

         boost::uint32_t *patomic_word = static_cast<boost::uint32_t*>(region.get_address());
         boost::uint32_t value = atomic_read32(patomic_word);

         while(value == InitializingSegment || value == UninitializedSegment){
            thread_yield();
            value = atomic_read32(patomic_word);
         }

         if(value != InitializedSegment)
            throw interprocess_exception(error_info(corrupted_error));

         construct_func( static_cast<char*>(region.get_address()) + ManagedOpenOrCreateUserOffset
                        , region.get_size() - ManagedOpenOrCreateUserOffset
                        , false);

         m_mapped_region.swap(region);
      }
      if(StoreDevice){
         this->DevHolder::get_device() = boost::move(dev);
      }
   }

   private:
   friend class interprocess_tester;
   void dont_close_on_destruction()
   { interprocess_tester::dont_close_on_destruction(m_mapped_region); }

   mapped_region m_mapped_region;
};

template<class DeviceAbstraction>
inline void swap(managed_open_or_create_impl<DeviceAbstraction> &x
                ,managed_open_or_create_impl<DeviceAbstraction> &y)
{ x.swap(y); }

}

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 483 "/opt/sevenflow/boost/include/boost/interprocess/detail/managed_open_or_create_impl.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp"
namespace boost {
namespace interprocess {
namespace ipcdetail {
# 93 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp"
inline void get_tmp_base_dir(std::string &tmp_name)
{






      tmp_name = get_temporary_path();

   if(tmp_name.empty()){
      error_info err = system_error_code();
      throw interprocess_exception(err);
   }

   tmp_name += "/boost_interprocess";
}

inline void tmp_folder(std::string &tmp_name)
{
   get_tmp_base_dir(tmp_name);




}

inline void tmp_filename(const char *filename, std::string &tmp_name)
{
   tmp_folder(tmp_name);
   tmp_name += "/";
   tmp_name += filename;
}

inline void create_tmp_and_clean_old(std::string &tmp_name)
{

   std::string root_tmp_name;
   get_tmp_base_dir(root_tmp_name);


   if(!create_directory(root_tmp_name.c_str())){
      error_info info(system_error_code());
      if(info.get_error_code() != already_exists_error){
         throw interprocess_exception(info);
      }
   }
# 156 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp"
      tmp_name = root_tmp_name;

}

inline void create_tmp_and_clean_old_and_get_filename(const char *filename, std::string &tmp_name)
{
   create_tmp_and_clean_old(tmp_name);
   tmp_name += "/";
   tmp_name += filename;
}

inline void add_leading_slash(const char *name, std::string &new_name)
{
   if(name[0] != '/'){
      new_name = '/';
   }
   new_name += name;
}

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 180 "/opt/sevenflow/boost/include/boost/interprocess/detail/tmp_dir_helpers.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 25 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp"
namespace boost {
namespace interprocess {



class shared_memory_object
{


   private: shared_memory_object(shared_memory_object &); shared_memory_object& operator=(shared_memory_object &); public: operator ::boost::rv<shared_memory_object>&() { return *static_cast< ::boost::rv<shared_memory_object>* >(this); } operator const ::boost::rv<shared_memory_object>&() const { return *static_cast<const ::boost::rv<shared_memory_object>* >(this); } private:


   public:

   shared_memory_object();



   shared_memory_object(create_only_t, const char *name, mode_t mode, const permissions &perm = permissions())
   { this->priv_open_or_create(ipcdetail::DoCreate, name, mode, perm); }




   shared_memory_object(open_or_create_t, const char *name, mode_t mode, const permissions &perm = permissions())
   { this->priv_open_or_create(ipcdetail::DoOpenOrCreate, name, mode, perm); }



   shared_memory_object(open_only_t, const char *name, mode_t mode)
   { this->priv_open_or_create(ipcdetail::DoOpen, name, mode, permissions()); }




   shared_memory_object(::boost::rv< shared_memory_object >& moved)
      : m_handle(file_handle_t(ipcdetail::invalid_file()))
   { this->swap(moved); }




   shared_memory_object &operator=(::boost::rv< shared_memory_object >& moved)
   {
      shared_memory_object tmp(boost::move(moved));
      this->swap(tmp);
      return *this;
   }


   void swap(shared_memory_object &moved);



   static bool remove(const char *name);


   void truncate(offset_t length);
# 113 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp"
   ~shared_memory_object();


   const char *get_name() const;



   bool get_size(offset_t &size) const;


   mode_t get_mode() const;


   mapping_handle_t get_mapping_handle() const;


   private:


   void priv_close();


   bool priv_open_or_create(ipcdetail::create_enum_t type, const char *filename, mode_t mode, const permissions &perm);

   file_handle_t m_handle;
   mode_t m_mode;
   std::string m_filename;

};



inline shared_memory_object::shared_memory_object()
   : m_handle(file_handle_t(ipcdetail::invalid_file()))
{}

inline shared_memory_object::~shared_memory_object()
{ this->priv_close(); }


inline const char *shared_memory_object::get_name() const
{ return m_filename.c_str(); }

inline bool shared_memory_object::get_size(offset_t &size) const
{ return ipcdetail::get_file_size((file_handle_t)m_handle, size); }

inline void shared_memory_object::swap(shared_memory_object &other)
{
   std::swap(m_handle, other.m_handle);
   std::swap(m_mode, other.m_mode);
   m_filename.swap(other.m_filename);
}

inline mapping_handle_t shared_memory_object::get_mapping_handle() const
{
   return ipcdetail::mapping_handle_from_file_handle(m_handle);
}

inline mode_t shared_memory_object::get_mode() const
{ return m_mode; }
# 248 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp"
namespace shared_memory_object_detail {
# 268 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp"
}

inline bool shared_memory_object::priv_open_or_create
   (ipcdetail::create_enum_t type,
    const char *filename,
    mode_t mode, const permissions &perm)
{





   const bool add_leading_slash = true;

   if(add_leading_slash){
      ipcdetail::add_leading_slash(filename, m_filename);
   }
   else{
      ipcdetail::create_tmp_and_clean_old_and_get_filename(filename, m_filename);
   }


   int oflag = 0;
   if(mode == read_only){
      oflag |= 00;
   }
   else if(mode == read_write){
      oflag |= 02;
   }
   else{
      error_info err(mode_error);
      throw interprocess_exception(err);
   }
   int unix_perm = perm.get_permissions();

   switch(type){
      case ipcdetail::DoOpen:
      {

         m_handle = shm_open(m_filename.c_str(), oflag, unix_perm);
      }
      break;
      case ipcdetail::DoCreate:
      {
         oflag |= (0100 | 0200);
         m_handle = shm_open(m_filename.c_str(), oflag, unix_perm);
         if(m_handle >= 0){
            ::fchmod(m_handle, unix_perm);
         }
      }
      break;
      case ipcdetail::DoOpenOrCreate:
      {
         oflag |= 0100;


         while(1){
            m_handle = shm_open(m_filename.c_str(), oflag, unix_perm);
            if(m_handle >= 0){
               ::fchmod(m_handle, unix_perm);
               break;
            }
            else if((*__errno_location ()) == 17){
               if((m_handle = shm_open(m_filename.c_str(), oflag, unix_perm)) >= 0 || (*__errno_location ()) != 2){
                  break;
               }
            }
         }
      }
      break;
      default:
      {
         error_info err = other_error;
         throw interprocess_exception(err);
      }
   }


   if(m_handle == -1){
      error_info err = (*__errno_location ());
      this->priv_close();
      throw interprocess_exception(err);
   }

   m_filename = filename;
   m_mode = mode;
   return true;
}

inline bool shared_memory_object::remove(const char *filename)
{
   try{
      std::string file_str;





      const bool add_leading_slash = true;

      if(add_leading_slash){
         ipcdetail::add_leading_slash(filename, file_str);
      }
      else{
         ipcdetail::tmp_filename(filename, file_str);
      }
      return 0 == shm_unlink(file_str.c_str());
   }
   catch(...){
      return false;
   }
}

inline void shared_memory_object::truncate(offset_t length)
{
   if(0 != ftruncate(m_handle, length)){
      error_info err(system_error_code());
      throw interprocess_exception(err);
   }
}

inline void shared_memory_object::priv_close()
{
   if(m_handle != -1){
      ::close(m_handle);
      m_handle = -1;
   }
}
# 405 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp"
class remove_shared_memory_on_destroy
{
   const char * m_name;
   public:
   remove_shared_memory_on_destroy(const char *name)
      : m_name(name)
   {}

   ~remove_shared_memory_on_destroy()
   { shared_memory_object::remove(m_name); }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 421 "/opt/sevenflow/boost/include/boost/interprocess/shared_memory_object.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp"
# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_cv.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/add_cv.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/add_cv.hpp" 2

namespace boost {
# 34 "/opt/sevenflow/boost/include/boost/type_traits/add_cv.hpp"
template< typename T > struct add_cv { public: typedef T const volatile type; };






template< typename T > struct add_cv<T&> { public: typedef T& type; };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/opt/sevenflow/boost/include/boost/type_traits/add_cv.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_lvalue_reference.hpp" 1
# 9 "/opt/sevenflow/boost/include/boost/type_traits/add_lvalue_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_reference.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/add_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/add_reference.hpp" 2

namespace boost {

namespace detail {
# 59 "/opt/sevenflow/boost/include/boost/type_traits/add_reference.hpp"
template <typename T>
struct add_reference_rvalue_layer
{
    typedef T& type;
};
# 73 "/opt/sevenflow/boost/include/boost/type_traits/add_reference.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 106 "/opt/sevenflow/boost/include/boost/type_traits/add_reference.hpp" 2
# 10 "/opt/sevenflow/boost/include/boost/type_traits/add_lvalue_reference.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/add_lvalue_reference.hpp" 2

namespace boost{

template< typename T > struct add_lvalue_reference { public: typedef typename boost::add_reference<T>::type type; };





}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/add_lvalue_reference.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_pointer.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/add_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_reference.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/type_traits/remove_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/remove_reference.hpp" 2

namespace boost {



namespace detail{




template <class T>
struct remove_rvalue_ref
{
   typedef T type;
};
# 45 "/opt/sevenflow/boost/include/boost/type_traits/remove_reference.hpp"
}

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 "/opt/sevenflow/boost/include/boost/type_traits/remove_reference.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 69 "/opt/sevenflow/boost/include/boost/type_traits/remove_reference.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/add_pointer.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/add_pointer.hpp" 2

namespace boost {

namespace detail {
# 55 "/opt/sevenflow/boost/include/boost/type_traits/add_pointer.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 71 "/opt/sevenflow/boost/include/boost/type_traits/add_pointer.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/add_rvalue_reference.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/type_traits/add_rvalue_reference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/add_rvalue_reference.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/add_rvalue_reference.hpp"
namespace boost {

namespace type_traits_detail {

    template <typename T, bool b>
    struct add_rvalue_reference_helper
    { typedef T type; };
# 50 "/opt/sevenflow/boost/include/boost/type_traits/add_rvalue_reference.hpp"
    template <typename T>
    struct add_rvalue_reference_imp
    {
       typedef typename boost::type_traits_detail::add_rvalue_reference_helper
                  <T, (!is_void<T>::value && !is_reference<T>::value) >::type type;
    };

}

template< typename T > struct add_rvalue_reference { public: typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type; };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 64 "/opt/sevenflow/boost/include/boost/type_traits/add_rvalue_reference.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/aligned_storage.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp" 1
# 29 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/typeof/typeof.hpp" 1
# 208 "/opt/sevenflow/boost/include/boost/typeof/typeof.hpp"
# 1 "/opt/sevenflow/boost/include/boost/typeof/message.hpp" 1
# 209 "/opt/sevenflow/boost/include/boost/typeof/typeof.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/typeof/native.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/typeof/native.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/false_result.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/false_result.hpp"
namespace boost {
namespace type_traits {


struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};

}}
# 16 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/is_function_ptr_helper.hpp"
}
}
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp" 2







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>
{
};
# 90 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp"
}






template< typename T > struct is_function : public ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { public: };




}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 105 "/opt/sevenflow/boost/include/boost/type_traits/is_function.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/typeof/native.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/utility/enable_if.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/utility/enable_if.hpp"
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> {};

}
# 23 "/opt/sevenflow/boost/include/boost/typeof/native.hpp" 2

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 "/opt/sevenflow/boost/include/boost/typeof/typeof.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp" 2
# 54 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/utility/declval.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/utility/declval.hpp"
namespace boost {


    template <typename T>
    typename add_rvalue_reference<T>::type declval() ;




}
# 55 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp" 2
# 66 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp"
    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 "/opt/sevenflow/boost/include/boost/type_traits/common_type.hpp"
}
# 23 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/conditional.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/conditional.hpp"
namespace boost {

template <bool b, class T, class U>
struct conditional : public mpl::if_c<b, T, U>
{
};

}
# 24 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/decay.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/decay.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_array.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/type_traits/is_array.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 25 "/opt/sevenflow/boost/include/boost/type_traits/is_array.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/type_traits/is_array.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/is_array.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 90 "/opt/sevenflow/boost/include/boost/type_traits/is_array.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/decay.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_bounds.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/remove_bounds.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 14 "/opt/sevenflow/boost/include/boost/type_traits/remove_bounds.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/remove_bounds.hpp" 2



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 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/opt/sevenflow/boost/include/boost/type_traits/remove_bounds.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/decay.hpp" 2





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

}
# 25 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/extent.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/extent.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2




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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/extent.hpp" 2

namespace boost {

namespace detail{
# 29 "/opt/sevenflow/boost/include/boost/type_traits/extent.hpp"
template <class T, std::size_t N>
struct extent_imp
{
   static const std::size_t value = 0;
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T volatile[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct extent_imp<T const volatile[R], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};

template <class T, std::size_t R>
struct extent_imp<T[R],0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T const[R], 0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T volatile[R], 0>
{
   static const std::size_t value = R;
};

template <class T, std::size_t R>
struct extent_imp<T const volatile[R], 0>
{
   static const std::size_t value = R;
};


template <class T, std::size_t N>
struct extent_imp<T[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T const[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T volatile[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T, std::size_t N>
struct extent_imp<T const volatile[], N>
{
   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
};
template <class T>
struct extent_imp<T[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T const[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T volatile[], 0>
{
   static const std::size_t value = 0;
};
template <class T>
struct extent_imp<T const volatile[], 0>
{
   static const std::size_t value = 0;
};




}

template <class T, std::size_t N = 0>
struct extent
   : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
{




   
};

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 144 "/opt/sevenflow/boost/include/boost/type_traits/extent.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/floating_point_promotion.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/type_traits/floating_point_promotion.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/floating_point_promotion.hpp" 2

namespace boost {

namespace type_traits { namespace detail {



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

template<>
struct floating_point_promotion<float>
{
    typedef double type;
};

template<>
struct floating_point_promotion<float const>
{
    typedef double const type;
};

template<>
struct floating_point_promotion<float volatile>
{
    typedef double volatile type;
};

template<>
struct floating_point_promotion<float const volatile>
{
    typedef double const volatile type;
};
# 78 "/opt/sevenflow/boost/include/boost/type_traits/floating_point_promotion.hpp"
} }

template< typename T > struct floating_point_promotion { public: typedef typename boost::type_traits::detail::floating_point_promotion<T>::type type; };





}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 89 "/opt/sevenflow/boost/include/boost/type_traits/floating_point_promotion.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/function_traits.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/type_traits/function_traits.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/function_traits.hpp"
}
# 28 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 14 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp" 2

namespace boost {
namespace detail {
    template <class U, U x>
    struct test;

    template <typename T>
    struct has_new_operator_impl {
        template<class U>
        static type_traits::yes_type check_sig1(
            U*,
            test<
            void *(*)(std::size_t),
                &U::operator new
            >* = __null
        );
        template<class U>
        static type_traits::no_type check_sig1(...);

        template<class U>
        static type_traits::yes_type check_sig2(
            U*,
            test<
            void *(*)(std::size_t, const std::nothrow_t&),
                &U::operator new
            >* = __null
        );
        template<class U>
        static type_traits::no_type check_sig2(...);

        template<class U>
        static type_traits::yes_type check_sig3(
            U*,
            test<
            void *(*)(std::size_t, void*),
                &U::operator new
            >* = __null
        );
        template<class U>
        static type_traits::no_type check_sig3(...);


        template<class U>
        static type_traits::yes_type check_sig4(
            U*,
            test<
            void *(*)(std::size_t),
                &U::operator new[]
            >* = __null
        );
        template<class U>
        static type_traits::no_type check_sig4(...);

        template<class U>
        static type_traits::yes_type check_sig5(
            U*,
            test<
            void *(*)(std::size_t, const std::nothrow_t&),
                &U::operator new[]
            >* = __null
        );
        template<class U>
        static type_traits::no_type check_sig5(...);

        template<class U>
        static type_traits::yes_type check_sig6(
            U*,
            test<
            void *(*)(std::size_t, void*),
                &U::operator new[]
            >* = __null
        );
        template<class U>
        static type_traits::no_type check_sig6(...);




            static const unsigned s1 = sizeof(has_new_operator_impl<T>::template check_sig1<T>(0));
            static const unsigned s2 = sizeof(has_new_operator_impl<T>::template check_sig2<T>(0));
            static const unsigned s3 = sizeof(has_new_operator_impl<T>::template check_sig3<T>(0));
            static const unsigned s4 = sizeof(has_new_operator_impl<T>::template check_sig4<T>(0));
            static const unsigned s5 = sizeof(has_new_operator_impl<T>::template check_sig5<T>(0));
            static const unsigned s6 = sizeof(has_new_operator_impl<T>::template check_sig6<T>(0));
# 121 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp"
        static const bool value = (::boost::type_traits::ice_or< (s1 == sizeof(type_traits::yes_type)), (s2 == sizeof(type_traits::yes_type)), (s3 == sizeof(type_traits::yes_type)), (s4 == sizeof(type_traits::yes_type)), (s5 == sizeof(type_traits::yes_type)), (s6 == sizeof(type_traits::yes_type)) >::value)
# 130 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp"
         ;
    };
}

template< typename T > struct has_new_operator : public ::boost::integral_constant<bool,::boost::detail::has_new_operator_impl<T>::value> { public: };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 139 "/opt/sevenflow/boost/include/boost/type_traits/has_new_operator.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_assign.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_assign.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_assign.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct has_trivial_assign_impl
{

   static const bool value = ((__has_trivial_assign(T) ) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value);
# 41 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_assign.hpp"
};

}

template< typename T > struct has_trivial_assign : public ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { public: };
template<> struct has_trivial_assign< void > : public ::boost::integral_constant<bool,false> { public: };

template<> struct has_trivial_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
template<> struct has_trivial_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
template<> struct has_trivial_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 56 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_assign.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_assign.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_assign.hpp" 2

namespace boost {

namespace detail{

template <class T>
struct has_nothrow_assign_imp{



   static const bool value = ((__has_nothrow_assign(T) ) && !is_volatile<T>::value && !is_const<T>::value);

};

}

template< typename T > struct has_nothrow_assign : public ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { public: };
template<> struct has_nothrow_assign< void > : public ::boost::integral_constant<bool,false> { public: };

template<> struct has_nothrow_assign< void const > : public ::boost::integral_constant<bool,false> { public: };
template<> struct has_nothrow_assign< void const volatile > : public ::boost::integral_constant<bool,false> { public: };
template<> struct has_nothrow_assign< void volatile > : public ::boost::integral_constant<bool,false> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_assign.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_constructor.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_constructor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_constructor.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_constructor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_constructor.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_constructor.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_constructor.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_constructor.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 52 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_constructor.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_copy.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_copy.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_copy.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_copy.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_copy.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 63 "/opt/sevenflow/boost/include/boost/type_traits/has_trivial_copy.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_copy.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_copy.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 52 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_copy.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_destructor.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_destructor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_destructor.hpp" 2

namespace boost {

template< typename T > struct has_nothrow_destructor : public ::boost::integral_constant<bool,::boost::has_trivial_destructor<T>::value> { public: };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/type_traits/has_nothrow_destructor.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_and.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_and.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_abstract.hpp" 1
# 62 "/opt/sevenflow/boost/include/boost/type_traits/is_abstract.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 63 "/opt/sevenflow/boost/include/boost/type_traits/is_abstract.hpp" 2


namespace boost {
namespace detail{


template <class T>
struct is_abstract_imp
{
   static const bool value = __is_abstract(T);
};
# 141 "/opt/sevenflow/boost/include/boost/type_traits/is_abstract.hpp"
}


template< typename T > struct is_abstract : public ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { public: };




}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 152 "/opt/sevenflow/boost/include/boost/type_traits/is_abstract.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 38 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp" 2

namespace boost {
# 53 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
namespace detail {
# 120 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    template <typename T> any_conversion(T&);
};

template <typename T> struct checker
{
    static boost::type_traits::no_type _m_check(any_conversion ...);
    static boost::type_traits::yes_type _m_check(T, int);
};

template <typename From, typename To>
struct is_convertible_basic_impl
{
    static typename add_rvalue_reference<From>::type _m_from;
    static bool const value = sizeof( boost::detail::checker<To>::_m_check(_m_from, 0) )
        == sizeof(::boost::type_traits::yes_type);
};
# 292 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
template <typename From, typename To>
struct is_convertible_impl
{
    typedef typename add_reference<From>::type ref_type;
    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value)
# 306 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
         ;
};


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
{};
# 395 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
    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); };
# 405 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 430 "/opt/sevenflow/boost/include/boost/type_traits/is_convertible.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_pointer.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/type_traits/remove_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/type_traits/remove_pointer.hpp" 2

namespace boost {
# 76 "/opt/sevenflow/boost/include/boost/type_traits/remove_pointer.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 91 "/opt/sevenflow/boost/include/boost/type_traits/remove_pointer.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_bit_and_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_bit_and_impl::dont_care > struct has_bit_and : public ::boost::integral_constant<bool,(::boost::detail::has_bit_and_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_and.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_and_assign.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_and_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_bit_and_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_and_assign_impl::dont_care > struct has_bit_and_assign : public ::boost::integral_constant<bool,(::boost::detail::has_bit_and_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_and_assign.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_or.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_or.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_bit_or_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_bit_or_impl::dont_care > struct has_bit_or : public ::boost::integral_constant<bool,(::boost::detail::has_bit_or_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_or.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_or_assign.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_or_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_bit_or_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_or_assign_impl::dont_care > struct has_bit_or_assign : public ::boost::integral_constant<bool,(::boost::detail::has_bit_or_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_or_assign.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_xor.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_xor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_bit_xor_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_bit_xor_impl::dont_care > struct has_bit_xor : public ::boost::integral_constant<bool,(::boost::detail::has_bit_xor_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_xor.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_xor_assign.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_xor_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_bit_xor_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_bit_xor_assign_impl::dont_care > struct has_bit_xor_assign : public ::boost::integral_constant<bool,(::boost::detail::has_bit_xor_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_bit_xor_assign.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_complement.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/type_traits/has_complement.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_complement_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator ~ (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value >::value >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_complement_impl::dont_care > struct has_complement : public ::boost::integral_constant<bool,(::boost::detail::has_complement_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 27 "/opt/sevenflow/boost/include/boost/type_traits/has_complement.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_dereference.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/has_dereference.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_dereference_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator * (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_dereference_impl::dont_care > struct has_dereference : public ::boost::integral_constant<bool,(::boost::detail::has_dereference_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 26 "/opt/sevenflow/boost/include/boost/type_traits/has_dereference.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_divides.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_divides.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_divides_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_divides_impl::dont_care > struct has_divides : public ::boost::integral_constant<bool,(::boost::detail::has_divides_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_divides.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_divides_assign.hpp" 1
# 41 "/opt/sevenflow/boost/include/boost/type_traits/has_divides_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_divides_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_const< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_divides_assign_impl::dont_care > struct has_divides_assign : public ::boost::integral_constant<bool,(::boost::detail::has_divides_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 42 "/opt/sevenflow/boost/include/boost/type_traits/has_divides_assign.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_equal_to.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_equal_to.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_equal_to_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_equal_to_impl::dont_care > struct has_equal_to : public ::boost::integral_constant<bool,(::boost::detail::has_equal_to_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_equal_to.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_greater.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_greater.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_greater_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_greater_impl::dont_care > struct has_greater : public ::boost::integral_constant<bool,(::boost::detail::has_greater_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_greater.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_greater_equal.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_greater_equal.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_greater_equal_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_greater_equal_impl::dont_care > struct has_greater_equal : public ::boost::integral_constant<bool,(::boost::detail::has_greater_equal_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_greater_equal.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_left_shift.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_left_shift.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_left_shift.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_left_shift_assign.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_left_shift_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_left_shift_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_left_shift_assign_impl::dont_care > struct has_left_shift_assign : public ::boost::integral_constant<bool,(::boost::detail::has_left_shift_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_left_shift_assign.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_less.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_less.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_less_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_less_impl::dont_care > struct has_less : public ::boost::integral_constant<bool,(::boost::detail::has_less_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_less.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_less_equal.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_less_equal.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_less_equal_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_less_equal_impl::dont_care > struct has_less_equal : public ::boost::integral_constant<bool,(::boost::detail::has_less_equal_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_less_equal.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_and.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_and.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_logical_and_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_logical_and_impl::dont_care > struct has_logical_and : public ::boost::integral_constant<bool,(::boost::detail::has_logical_and_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_and.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_not.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_not.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_logical_not_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator ! (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, false >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_logical_not_impl::dont_care > struct has_logical_not : public ::boost::integral_constant<bool,(::boost::detail::has_logical_not_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 18 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_not.hpp" 2
# 31 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_or.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_or.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_logical_or_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Rhs_nocv, bool >::value >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_convertible< Lhs_nocv, bool >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_logical_or_impl::dont_care > struct has_logical_or : public ::boost::integral_constant<bool,(::boost::detail::has_logical_or_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_logical_or.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_minus.hpp" 1
# 54 "/opt/sevenflow/boost/include/boost/type_traits/has_minus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_minus_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::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_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, Rhs_nocv >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_minus_impl::dont_care > struct has_minus : public ::boost::integral_constant<bool,(::boost::detail::has_minus_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 55 "/opt/sevenflow/boost/include/boost/type_traits/has_minus.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_minus_assign.hpp" 1
# 59 "/opt/sevenflow/boost/include/boost/type_traits/has_minus_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_minus_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::is_fundamental< Lhs_nocv >::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_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_minus_assign_impl::dont_care > struct has_minus_assign : public ::boost::integral_constant<bool,(::boost::detail::has_minus_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 60 "/opt/sevenflow/boost/include/boost/type_traits/has_minus_assign.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_modulus.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_modulus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_modulus_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_modulus_impl::dont_care > struct has_modulus : public ::boost::integral_constant<bool,(::boost::detail::has_modulus_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_modulus.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_modulus_assign.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_modulus_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_modulus_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_modulus_assign_impl::dont_care > struct has_modulus_assign : public ::boost::integral_constant<bool,(::boost::detail::has_modulus_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_modulus_assign.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_multiplies.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_multiplies.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_multiplies_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_multiplies_impl::dont_care > struct has_multiplies : public ::boost::integral_constant<bool,(::boost::detail::has_multiplies_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_multiplies.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_multiplies_assign.hpp" 1
# 41 "/opt/sevenflow/boost/include/boost/type_traits/has_multiplies_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_multiplies_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_const< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_multiplies_assign_impl::dont_care > struct has_multiplies_assign : public ::boost::integral_constant<bool,(::boost::detail::has_multiplies_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 42 "/opt/sevenflow/boost/include/boost/type_traits/has_multiplies_assign.hpp" 2
# 38 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_negate.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/type_traits/has_negate.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_negate_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator - (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, ::boost::is_pointer< Rhs_noref >::value >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_negate_impl::dont_care > struct has_negate : public ::boost::integral_constant<bool,(::boost::detail::has_negate_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 20 "/opt/sevenflow/boost/include/boost/type_traits/has_negate.hpp" 2
# 39 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_not_equal_to.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_not_equal_to.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_not_equal_to_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value, ::boost::type_traits::ice_not< ::boost::type_traits::ice_or< ::boost::is_base_of< Lhs_noptr, Rhs_noptr >::value, ::boost::is_base_of< Rhs_noptr, Lhs_noptr >::value, ::boost::is_same< Lhs_noptr, Rhs_noptr >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_void< Rhs_noptr >::value >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_not_equal_to_impl::dont_care > struct has_not_equal_to : public ::boost::integral_constant<bool,(::boost::detail::has_not_equal_to_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_not_equal_to.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_plus.hpp" 1
# 48 "/opt/sevenflow/boost/include/boost/type_traits/has_plus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_plus_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Lhs_noref >::value >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_plus_impl::dont_care > struct has_plus : public ::boost::integral_constant<bool,(::boost::detail::has_plus_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_plus.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_plus_assign.hpp" 1
# 60 "/opt/sevenflow/boost/include/boost/type_traits/has_plus_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_plus_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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_pointer< Lhs_noref >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value, ::boost::is_fundamental< Rhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value, ::boost::is_fundamental< Lhs_nocv >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_integral< Rhs_noref >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_fundamental< Lhs_nocv >::value, ::boost::type_traits::ice_not< ::boost::is_same< Lhs_nocv, bool >::value >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_plus_assign_impl::dont_care > struct has_plus_assign : public ::boost::integral_constant<bool,(::boost::detail::has_plus_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 61 "/opt/sevenflow/boost/include/boost/type_traits/has_plus_assign.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_post_decrement.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_post_decrement.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 2



          
# 27 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_post_decrement_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator -- (const any&, int);
# 68 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_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 >
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>() --,returns_void_t()))));
};





struct dont_care { };

template < typename Lhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Lhs >
struct operator_returns_Ret < Lhs, dont_care, true > {
   static const bool value = true;
};

template < typename Lhs >
struct operator_returns_Ret < Lhs, dont_care, false > {
   static const bool value = true;
};

template < typename Lhs >
struct operator_returns_Ret < Lhs, void, true > {
   static const bool value = true;
};

template < typename Lhs >
struct operator_returns_Ret < Lhs, void, false > {
   static const bool value = false;
};

template < typename Lhs, typename Ret >
struct operator_returns_Ret < Lhs, Ret, true > {
   static const bool value = false;
};




template < typename Lhs, typename Ret >
struct operator_returns_Ret < Lhs, 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>() --))==sizeof(::boost::type_traits::yes_type));
};
# 136 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < typename Lhs >
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<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 155 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
template < typename Lhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, Ret, true > {
   static const bool value = false;
};

template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs >::value, operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Lhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
   typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
   static const bool value = (trait_impl1 < Lhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Lhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Ret=::boost::detail::has_post_decrement_impl::dont_care > struct has_post_decrement : public ::boost::integral_constant<bool,(::boost::detail::has_post_decrement_impl::trait_impl< Lhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 202 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_post_decrement.hpp" 2
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_post_increment.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_post_increment.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 2



          
# 27 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_post_increment_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator ++ (const any&, int);
# 68 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_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 >
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>() ++,returns_void_t()))));
};





struct dont_care { };

template < typename Lhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Lhs >
struct operator_returns_Ret < Lhs, dont_care, true > {
   static const bool value = true;
};

template < typename Lhs >
struct operator_returns_Ret < Lhs, dont_care, false > {
   static const bool value = true;
};

template < typename Lhs >
struct operator_returns_Ret < Lhs, void, true > {
   static const bool value = true;
};

template < typename Lhs >
struct operator_returns_Ret < Lhs, void, false > {
   static const bool value = false;
};

template < typename Lhs, typename Ret >
struct operator_returns_Ret < Lhs, Ret, true > {
   static const bool value = false;
};




template < typename Lhs, typename Ret >
struct operator_returns_Ret < Lhs, 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>() ++))==sizeof(::boost::type_traits::yes_type));
};
# 136 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < typename Lhs >
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<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 155 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 3
template < typename Lhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, Ret, true > {
   static const bool value = false;
};

template < typename Lhs, typename Ret >
struct trait_impl1 < Lhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Lhs >::value, operator_returns_Ret < Lhs, Ret, operator_returns_void < Lhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Lhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Lhs>::type Lhs_noref;
   typedef typename ::boost::remove_cv<Lhs_noref>::type Lhs_nocv;
   typedef typename ::boost::remove_cv< typename ::boost::remove_reference< typename ::boost::remove_pointer<Lhs_noref>::type >::type >::type Lhs_noptr;
   static const bool value = (trait_impl1 < Lhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Lhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Lhs_noref >::value, ::boost::is_void< Lhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_pointer< Lhs_noref >::value >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Ret=::boost::detail::has_post_increment_impl::dont_care > struct has_post_increment : public ::boost::integral_constant<bool,(::boost::detail::has_post_increment_impl::trait_impl< Lhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 202 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_postfix_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_post_increment.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_pre_decrement.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_pre_decrement.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_pre_decrement_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator -- (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Rhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Rhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_pre_decrement_impl::dont_care > struct has_pre_decrement : public ::boost::integral_constant<bool,(::boost::detail::has_pre_decrement_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_pre_decrement.hpp" 2
# 45 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_pre_increment.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/type_traits/has_pre_increment.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_pre_increment_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator ++ (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, ::boost::type_traits::ice_or< ::boost::is_same< bool, Rhs_nocv >::value, ::boost::type_traits::ice_and< ::boost::is_pointer< Rhs_noref >::value, ::boost::is_void< Rhs_noptr >::value >::value, ::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_pointer< Rhs_noref >::value >::value, ::boost::is_const< Rhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_pre_increment_impl::dont_care > struct has_pre_increment : public ::boost::integral_constant<bool,(::boost::detail::has_pre_increment_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 35 "/opt/sevenflow/boost/include/boost/type_traits/has_pre_increment.hpp" 2
# 46 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_right_shift.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/type_traits/has_right_shift.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 44 "/opt/sevenflow/boost/include/boost/type_traits/has_right_shift.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_right_shift_assign.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_right_shift_assign.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp"
          
# 41 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_right_shift_assign_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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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 "/opt/sevenflow/boost/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, ::boost::type_traits::ice_and< ::boost::is_fundamental< Lhs_nocv >::value, ::boost::is_fundamental< Rhs_nocv >::value, ::boost::is_const< Lhs_noref >::value >::value >::value >::value);
};

}
}


template< typename Lhs, typename Rhs=Lhs, typename Ret=::boost::detail::has_right_shift_assign_impl::dont_care > struct has_right_shift_assign : public ::boost::integral_constant<bool,(::boost::detail::has_right_shift_assign_impl::trait_impl < Lhs, Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 229 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_right_shift_assign.hpp" 2
# 48 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_unary_minus.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/type_traits/has_unary_minus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_unary_minus_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator - (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, ::boost::is_pointer< Rhs_noref >::value >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_unary_minus_impl::dont_care > struct has_unary_minus : public ::boost::integral_constant<bool,(::boost::detail::has_unary_minus_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 20 "/opt/sevenflow/boost/include/boost/type_traits/has_unary_minus.hpp" 2
# 49 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_unary_plus.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/has_unary_plus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp"
          
# 35 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3





namespace boost {
namespace detail {


namespace has_unary_plus_impl {



template <typename T> T &make();







struct no_operator { };




struct any { template <class T> any(T const&); };


no_operator operator + (const any&);
# 76 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_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 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<Rhs>(),returns_void_t()))));
};





struct dont_care { };

template < typename Rhs, typename Ret, bool Returns_void >
struct operator_returns_Ret;

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, dont_care, false > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, true > {
   static const bool value = true;
};

template < typename Rhs >
struct operator_returns_Ret < Rhs, void, false > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct operator_returns_Ret < Rhs, Ret, true > {
   static const bool value = false;
};




template < typename Rhs, typename Ret >
struct operator_returns_Ret < 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<Rhs>()))==sizeof(::boost::type_traits::yes_type));
};
# 144 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
struct has_operator { };
no_operator operator,(no_operator, has_operator);

template < 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<Rhs>()),make<has_operator>())))==sizeof(::boost::type_traits::yes_type));
};
# 163 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 3
template < typename Rhs, typename Ret, bool Forbidden_if >
struct trait_impl1;

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, true > {
   static const bool value = false;
};

template < typename Rhs, typename Ret >
struct trait_impl1 < Rhs, Ret, false > {
   static const bool value = ( ::boost::type_traits::ice_and< operator_exists < Rhs >::value, operator_returns_Ret < Rhs, Ret, operator_returns_void < Rhs >::value >::value >::value )






    ;
};


template < typename Ret >
struct trait_impl1 < void, Ret, false > {
   static const bool value = false;
};


template < typename Rhs, typename Ret >
struct trait_impl {
   typedef typename ::boost::remove_reference<Rhs>::type Rhs_noref;
   typedef typename ::boost::remove_cv<Rhs_noref>::type Rhs_nocv;
   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 < Rhs_noref, Ret, false >::value);
};

}
}


template< typename Rhs, typename Ret=::boost::detail::has_unary_plus_impl::dont_care > struct has_unary_plus : public ::boost::integral_constant<bool,(::boost::detail::has_unary_plus_impl::trait_impl < Rhs, Ret >::value)> { public: };

}





# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 210 "/opt/sevenflow/boost/include/boost/type_traits/detail/has_prefix_operator.hpp" 2 3
# 18 "/opt/sevenflow/boost/include/boost/type_traits/has_unary_plus.hpp" 2
# 50 "/opt/sevenflow/boost/include/boost/type_traits/has_operator.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/type_traits/has_virtual_destructor.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/has_virtual_destructor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/type_traits/has_virtual_destructor.hpp" 2

namespace boost {


template< typename T > struct has_virtual_destructor : public ::boost::integral_constant<bool,__has_virtual_destructor(T)> { public: };




}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/type_traits/has_virtual_destructor.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_complex.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/type_traits/is_complex.hpp"
# 1 "/usr/include/c++/4.8.2/complex" 1 3
# 39 "/usr/include/c++/4.8.2/complex" 3
       
# 40 "/usr/include/c++/4.8.2/complex" 3




# 1 "/usr/include/c++/4.8.2/cmath" 1 3
# 39 "/usr/include/c++/4.8.2/cmath" 3
       
# 40 "/usr/include/c++/4.8.2/cmath" 3
# 45 "/usr/include/c++/4.8.2/complex" 2 3





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

# 63 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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;
    };


}
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_complex.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_complex.hpp" 2


namespace boost {
namespace detail{

struct is_convertible_from_tester
{
   template <class T>
   is_convertible_from_tester(const std::complex<T>&);
};

}

template< typename T > struct is_complex : public ::boost::integral_constant<bool,(::boost::is_convertible<T, boost::detail::is_convertible_from_tester>::value)> { public: };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 33 "/opt/sevenflow/boost/include/boost/type_traits/is_complex.hpp" 2
# 48 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_compound.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/is_compound.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/is_compound.hpp" 2

namespace boost {


namespace detail {

template <typename T>
struct is_compound_impl
{
   static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value)


                 ;
};

}





template< typename T > struct is_compound : public ::boost::integral_constant<bool,::boost::detail::is_compound_impl<T>::value> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 45 "/opt/sevenflow/boost/include/boost/type_traits/is_compound.hpp" 2
# 49 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_empty.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/type_traits/is_empty.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/type_traits/is_empty.hpp" 2







namespace boost {

namespace detail {
# 51 "/opt/sevenflow/boost/include/boost/type_traits/is_empty.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/is_empty.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 225 "/opt/sevenflow/boost/include/boost/type_traits/is_empty.hpp" 2
# 52 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_floating_point.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_floating_point.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/is_floating_point.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/type_traits/is_floating_point.hpp" 2
# 55 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_member_object_pointer.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_member_object_pointer.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/type_traits/is_member_object_pointer.hpp" 2

namespace boost {

namespace detail{

template <typename T>
struct is_member_object_pointer_impl
{
   static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value )





                 ;
};

}

template< typename T > struct is_member_object_pointer : public ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { public: };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 45 "/opt/sevenflow/boost/include/boost/type_traits/is_member_object_pointer.hpp" 2
# 61 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_object.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_object.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/type_traits/is_object.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_object_impl
{

   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value)




                ;







};

}

template< typename T > struct is_object : public ::boost::integral_constant<bool,::boost::detail::is_object_impl<T>::value> { public: };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 52 "/opt/sevenflow/boost/include/boost/type_traits/is_object.hpp" 2
# 63 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_polymorphic.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/type_traits/is_polymorphic.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/is_polymorphic.hpp" 2


namespace boost{
# 106 "/opt/sevenflow/boost/include/boost/type_traits/is_polymorphic.hpp"
template< typename T > struct is_polymorphic : public ::boost::integral_constant<bool,__is_polymorphic(T)> { public: };



}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 113 "/opt/sevenflow/boost/include/boost/type_traits/is_polymorphic.hpp" 2
# 65 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_stateless.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/type_traits/is_stateless.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/is_stateless.hpp" 2

namespace boost {

namespace detail {

template <typename T>
struct is_stateless_impl
{
  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value)






               ;
};

}

template< typename T > struct is_stateless : public ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { public: };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 47 "/opt/sevenflow/boost/include/boost/type_traits/is_stateless.hpp" 2
# 72 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_union.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/type_traits/is_union.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/type_traits/is_union.hpp" 2

namespace boost {

namespace detail {
# 40 "/opt/sevenflow/boost/include/boost/type_traits/is_union.hpp"
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 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1
# 56 "/opt/sevenflow/boost/include/boost/type_traits/is_union.hpp" 2
# 73 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/and.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/and.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/and.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/nested_type_wknd.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/aux_/nested_type_wknd.hpp"
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
    : T::type
{
};
}}}
# 24 "/opt/sevenflow/boost/include/boost/mpl/and.hpp" 2
# 42 "/opt/sevenflow/boost/include/boost/mpl/and.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/compiler.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/preprocessor/stringize.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/and.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 43 "/opt/sevenflow/boost/include/boost/mpl/and.hpp" 2
# 14 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/not.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/not.hpp"
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> { }; }

}}
# 15 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_def.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 2

namespace boost {
namespace detail {






       
# 28 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 3


template<typename Base, typename Derived, typename tag>
struct is_virtual_base_of_impl
{
    static const bool value = false;
};

template<typename Base, typename Derived>
struct is_virtual_base_of_impl<Base, Derived, mpl::true_>
{
# 55 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 3
    struct boost_type_traits_internal_struct_X : public Derived, virtual Base
    {
       boost_type_traits_internal_struct_X();
       boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
       boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
       ~boost_type_traits_internal_struct_X()throw();
    };
    struct boost_type_traits_internal_struct_Y : public Derived
    {
       boost_type_traits_internal_struct_Y();
       boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
       boost_type_traits_internal_struct_Y& operator=(const boost_type_traits_internal_struct_Y&);
       ~boost_type_traits_internal_struct_Y()throw();
    };

    static const bool value = (sizeof(boost_type_traits_internal_struct_X)==sizeof(boost_type_traits_internal_struct_Y));
};

template<typename Base, typename Derived>
struct is_virtual_base_of_impl2
{
   typedef typename mpl::and_<is_base_of<Base, Derived>, mpl::not_<is_same<Base, Derived> > >::type tag_type;
   typedef is_virtual_base_of_impl<Base, Derived, tag_type> imp;
   static const bool value = imp::value;
};





}

template< typename Base, typename Derived > struct is_virtual_base_of : public ::boost::integral_constant<bool,(::boost::detail::is_virtual_base_of_impl2<Base,Derived>::value)> { public: };







template< typename Base, typename Derived > struct is_virtual_base_of< Base&,Derived > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_virtual_base_of< Base,Derived& > : public ::boost::integral_constant<bool,false> { public: };
template< typename Base, typename Derived > struct is_virtual_base_of< Base&,Derived& > : public ::boost::integral_constant<bool,false> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3
# 103 "/opt/sevenflow/boost/include/boost/type_traits/is_virtual_base_of.hpp" 2 3
# 76 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/make_signed.hpp" 1
# 29 "/opt/sevenflow/boost/include/boost/type_traits/make_signed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/type_traits/make_signed.hpp" 2

namespace boost {

namespace detail {

template <class T>
struct make_signed_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_39
                                                                                                         ;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_43

                                                            ;


   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_signed<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, unsigned char>,
            signed char,
            typename mpl::if_<
               is_same<t_no_cv, unsigned short>,
               signed short,
               typename mpl::if_<
                  is_same<t_no_cv, unsigned int>,
                  int,
                  typename mpl::if_<
                     is_same<t_no_cv, unsigned long>,
                     long,

                     boost::long_long_type





                  >::type
               >::type
            >::type
         >::type,

         typename mpl::if_c<
            sizeof(t_no_cv) == sizeof(unsigned char),
            signed char,
            typename mpl::if_c<
               sizeof(t_no_cv) == sizeof(unsigned short),
               signed short,
               typename mpl::if_c<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  int,
                  typename mpl::if_c<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     long,

                     boost::long_long_type





                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename mpl::if_<
      is_const<T>,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;


   typedef typename mpl::if_<
      is_volatile<T>,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};


}

template< typename T > struct make_signed { public: typedef typename boost::detail::make_signed_imp<T>::type type; };

}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 135 "/opt/sevenflow/boost/include/boost/type_traits/make_signed.hpp" 2
# 79 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/rank.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/rank.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2




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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 20 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_def.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/rank.hpp" 2

namespace boost {



namespace detail{

template <class T, std::size_t N>
struct rank_imp
{
   static const std::size_t value = N;
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T const[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T volatile[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};

template <class T, std::size_t R, std::size_t N>
struct rank_imp<T const volatile[R], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};


template <class T, std::size_t N>
struct rank_imp<T[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T const[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T volatile[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};
template <class T, std::size_t N>
struct rank_imp<T const volatile[], N>
{
   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
};


}






template< typename T > struct rank : public ::boost::integral_constant<std::size_t,(::boost::detail::rank_imp<T,0>::value)> { public: };


}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/size_t_trait_undef.hpp" 1
# 88 "/opt/sevenflow/boost/include/boost/type_traits/rank.hpp" 2
# 80 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_extent.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/remove_extent.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 15 "/opt/sevenflow/boost/include/boost/type_traits/remove_extent.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/remove_extent.hpp" 2



namespace boost {

template< typename T > struct remove_extent { public: typedef T type; };


template< typename T, std::size_t N > struct remove_extent<T[N]> { public: typedef T type; };
template< typename T, std::size_t N > struct remove_extent<T const[N]> { public: typedef T const type; };
template< typename T, std::size_t N > struct remove_extent<T volatile[N]> { public: typedef T volatile type; };
template< typename T, std::size_t N > struct remove_extent<T const volatile[N]> { public: typedef T const volatile type; };

template< typename T > struct remove_extent<T[]> { public: typedef T type; };
template< typename T > struct remove_extent<T const[]> { public: typedef T const type; };
template< typename T > struct remove_extent<T volatile[]> { public: typedef T volatile type; };
template< typename T > struct remove_extent<T const volatile[]> { public: typedef T const volatile type; };



}



# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/opt/sevenflow/boost/include/boost/type_traits/remove_extent.hpp" 2
# 82 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_all_extents.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/type_traits/remove_all_extents.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 14 "/opt/sevenflow/boost/include/boost/type_traits/remove_all_extents.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/type_traits/remove_all_extents.hpp" 2



namespace boost {

template< typename T > struct remove_all_extents { public: typedef T type; };


template< typename T, std::size_t N > struct remove_all_extents<T[N]> { public: typedef typename boost::remove_all_extents<T>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T const[N]> { public: typedef typename boost::remove_all_extents<T const>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T volatile[N]> { public: typedef typename boost::remove_all_extents<T volatile>::type type; };
template< typename T, std::size_t N > struct remove_all_extents<T const volatile[N]> { public: typedef typename boost::remove_all_extents<T const volatile>::type type; };

template< typename T > struct remove_all_extents<T[]> { public: typedef typename boost::remove_all_extents<T>::type type; };
template< typename T > struct remove_all_extents<T const[]> { public: typedef typename boost::remove_all_extents<T const>::type type; };
template< typename T > struct remove_all_extents<T volatile[]> { public: typedef typename boost::remove_all_extents<T volatile>::type type; };
template< typename T > struct remove_all_extents<T const volatile[]> { public: typedef typename boost::remove_all_extents<T const volatile>::type type; };



}



# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 47 "/opt/sevenflow/boost/include/boost/type_traits/remove_all_extents.hpp" 2
# 83 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp"
}



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 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 89 "/opt/sevenflow/boost/include/boost/type_traits/remove_const.hpp" 2
# 84 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp" 2

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 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp"
}



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 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 87 "/opt/sevenflow/boost/include/boost/type_traits/remove_volatile.hpp" 2
# 88 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp" 2

namespace boost {

namespace type_traits { namespace detail {


template <class T> struct need_promotion : public boost::is_enum<T> {};


template<> struct need_promotion<char > : public true_type {};
template<> struct need_promotion<signed char > : public true_type {};
template<> struct need_promotion<unsigned char > : public true_type {};
template<> struct need_promotion<signed short int > : public true_type {};
template<> struct need_promotion<unsigned short int> : public true_type {};
# 63 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
template<> struct need_promotion<boost::ulong_long_type> : public integral_constant<bool, (sizeof(boost::ulong_long_type) < sizeof(int))> {};
template<> struct need_promotion<boost::long_long_type> : public integral_constant<bool, (sizeof(boost::long_long_type) < sizeof(int))> {};
# 75 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
template<> struct need_promotion<wchar_t> : public true_type {};





template<> struct need_promotion<bool> : public true_type {};




template<int Index, int IsConst, int IsVolatile> struct promote_from_index;
# 95 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
template<> struct promote_from_index<1,0,0> { typedef int type; }; template<> struct promote_from_index<1,0,1> { typedef int volatile type; }; template<> struct promote_from_index<1,1,0> { typedef int const type; }; template<> struct promote_from_index<1,1,1> { typedef int const volatile type; };
template<> struct promote_from_index<2,0,0> { typedef unsigned int type; }; template<> struct promote_from_index<2,0,1> { typedef unsigned int volatile type; }; template<> struct promote_from_index<2,1,0> { typedef unsigned int const type; }; template<> struct promote_from_index<2,1,1> { typedef unsigned int const volatile type; };
template<> struct promote_from_index<3,0,0> { typedef long type; }; template<> struct promote_from_index<3,0,1> { typedef long volatile type; }; template<> struct promote_from_index<3,1,0> { typedef long const type; }; template<> struct promote_from_index<3,1,1> { typedef long const volatile type; };
template<> struct promote_from_index<4,0,0> { typedef unsigned long type; }; template<> struct promote_from_index<4,0,1> { typedef unsigned long volatile type; }; template<> struct promote_from_index<4,1,0> { typedef unsigned long const type; }; template<> struct promote_from_index<4,1,1> { typedef unsigned long const volatile type; };
# 107 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
template<> struct promote_from_index<5,0,0> { typedef boost::long_long_type type; }; template<> struct promote_from_index<5,0,1> { typedef boost::long_long_type volatile type; }; template<> struct promote_from_index<5,1,0> { typedef boost::long_long_type const type; }; template<> struct promote_from_index<5,1,1> { typedef boost::long_long_type const volatile type; };
template<> struct promote_from_index<6,0,0> { typedef boost::ulong_long_type type; }; template<> struct promote_from_index<6,0,1> { typedef boost::ulong_long_type volatile type; }; template<> struct promote_from_index<6,1,0> { typedef boost::ulong_long_type const type; }; template<> struct promote_from_index<6,1,1> { typedef boost::ulong_long_type const volatile type; };
# 120 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
template<int N>
struct sized_type_for_promotion
{
    typedef char (&type)[N];
};
# 136 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
sized_type_for_promotion<1>::type promoted_index_tester(int);
sized_type_for_promotion<2>::type promoted_index_tester(unsigned int);
sized_type_for_promotion<3>::type promoted_index_tester(long);
sized_type_for_promotion<4>::type promoted_index_tester(unsigned long);


sized_type_for_promotion<5>::type promoted_index_tester(boost::long_long_type);
sized_type_for_promotion<6>::type promoted_index_tester(boost::ulong_long_type);
# 154 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp"
template<class T>
struct promoted_index
{
    static T testee;
    static const int value = sizeof(promoted_index_tester(+testee));

};

template<class T>
struct integral_promotion_impl
{
    typedef typename promote_from_index<
        (boost::type_traits::detail::promoted_index<T>::value)
      , (boost::is_const<T>::value)
      , (boost::is_volatile<T>::value)
      >::type type;
};

template<class T>
struct integral_promotion
  : public boost::mpl::eval_if<
        need_promotion<typename remove_cv<T>::type>
      , integral_promotion_impl<T>
      , boost::mpl::identity<T>
      >
{
};

} }

template< typename T > struct integral_promotion { public: typedef typename boost::type_traits::detail::integral_promotion<T>::type type; };





}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 193 "/opt/sevenflow/boost/include/boost/type_traits/integral_promotion.hpp" 2
# 91 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type_traits/promote.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/promote.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/template_arity_spec.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_def.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/type_traits/promote.hpp" 2

namespace boost {

namespace detail {

template<class T>
struct promote_impl
  : public integral_promotion<
        typename floating_point_promotion<T>::type
      >
{
};

}

template< typename T > struct promote { public: typedef typename boost::detail::promote_impl<T>::type type; };




}

# 1 "/opt/sevenflow/boost/include/boost/type_traits/detail/type_trait_undef.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/type_traits/promote.hpp" 2
# 92 "/opt/sevenflow/boost/include/boost/type_traits.hpp" 2
# 39 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2


# 1 "/usr/include/c++/4.8.2/climits" 1 3
# 39 "/usr/include/c++/4.8.2/climits" 3
       
# 40 "/usr/include/c++/4.8.2/climits" 3

# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/climits" 2 3
# 42 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstring" 1 3
# 39 "/usr/include/c++/4.8.2/cstring" 3
       
# 40 "/usr/include/c++/4.8.2/cstring" 3
# 43 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 46 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2
# 60 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp"
namespace boost {
namespace interprocess {



template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
class rbtree_best_fit
{


   rbtree_best_fit();
   rbtree_best_fit(const rbtree_best_fit &);
   rbtree_best_fit &operator=(const rbtree_best_fit &);

   private:
   struct block_ctrl;
   typedef typename boost::intrusive::
      pointer_traits<VoidPointer>::template
         rebind_pointer<block_ctrl>::type block_ctrl_ptr;

   typedef typename boost::intrusive::
      pointer_traits<VoidPointer>::template
         rebind_pointer<char>::type char_ptr;



   public:

   typedef MutexFamily mutex_family;

   typedef VoidPointer void_pointer;
   typedef boost::container::container_detail::
      basic_multiallocation_chain<VoidPointer> multiallocation_chain;

   typedef typename boost::intrusive::pointer_traits<char_ptr>::difference_type difference_type;
   typedef typename boost::make_unsigned<difference_type>::type size_type;



   private:

   typedef typename bi::make_set_base_hook
      < bi::void_pointer<VoidPointer>
      , bi::optimize_size<true>
      , bi::link_mode<bi::normal_link> >::type TreeHook;

   struct SizeHolder
   {


      size_type m_prev_size : sizeof(size_type)*8;
      size_type m_size : sizeof(size_type)*8 - 2;
      size_type m_prev_allocated : 1;
      size_type m_allocated : 1;
   };


   struct block_ctrl
      : public SizeHolder, public TreeHook
   {
      block_ctrl()
      { this->m_size = 0; this->m_allocated = 0, this->m_prev_allocated = 0; }

      friend bool operator<(const block_ctrl &a, const block_ctrl &b)
      { return a.m_size < b.m_size; }
      friend bool operator==(const block_ctrl &a, const block_ctrl &b)
      { return a.m_size == b.m_size; }
   };

   struct size_block_ctrl_compare
   {
      bool operator()(size_type size, const block_ctrl &block) const
      { return size < block.m_size; }

      bool operator()(const block_ctrl &block, size_type size) const
      { return block.m_size < size; }
   };


   typedef typename MutexFamily::mutex_type mutex_type;
   typedef typename bi::make_multiset
      <block_ctrl, bi::base_hook<TreeHook> >::type Imultiset;

   typedef typename Imultiset::iterator imultiset_iterator;



   struct header_t : public mutex_type
   {
      Imultiset m_imultiset;


      size_type m_extra_hdr_bytes;

      size_type m_allocated;

      size_type m_size;
   } m_header;

   friend class ipcdetail::memory_algorithm_common<rbtree_best_fit>;

   typedef ipcdetail::memory_algorithm_common<rbtree_best_fit> algo_impl_t;

   public:





   rbtree_best_fit (size_type size, size_type extra_hdr_bytes);


   ~rbtree_best_fit();


   static size_type get_min_size (size_type extra_hdr_bytes);




   void* allocate (size_type nbytes);






   multiallocation_chain allocate_many(size_type elem_bytes, size_type num_elements)
   {


      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      return algo_impl_t::allocate_many(this, elem_bytes, num_elements);
   }


   multiallocation_chain allocate_many(const size_type *elem_sizes, size_type n_elements, size_type sizeof_element)
   {


      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      return algo_impl_t::allocate_many(this, elem_sizes, n_elements, sizeof_element);
   }


   void deallocate_many(multiallocation_chain chain);




   void deallocate (void *addr);


   size_type get_size() const;


   size_type get_free_memory() const;



   void zero_free_memory();



   void grow(size_type extra_size);


   void shrink_to_fit();


   bool all_memory_deallocated();



   bool check_sanity();

   template<class T>
   std::pair<T *, bool>
      allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
                           size_type preferred_size,size_type &received_size,
                           T *reuse_ptr = 0);

   std::pair<void *, bool>
     raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_object,
                              size_type preferred_object,size_type &received_object,
                              void *reuse_ptr = 0, size_type sizeof_object = 1);


   size_type size(const void *ptr) const;



   void* allocate_aligned (size_type nbytes, size_type alignment);


   private:
   static size_type priv_first_block_offset_from_this(const void *this_ptr, size_type extra_hdr_bytes);

   block_ctrl *priv_first_block();

   block_ctrl *priv_end_block();

   std::pair<void*, bool>
      priv_allocation_command(boost::interprocess::allocation_type command, size_type limit_size,
                        size_type preferred_size,size_type &received_size,
                        void *reuse_ptr, size_type sizeof_object);



   std::pair<void *, bool> priv_allocate(boost::interprocess::allocation_type command
                                        ,size_type limit_size
                                        ,size_type preferred_size
                                        ,size_type &received_size
                                        ,void *reuse_ptr = 0
                                        ,size_type backwards_multiple = 1);


   static block_ctrl *priv_get_block(const void *ptr);


   static void *priv_get_user_buffer(const block_ctrl *block);



   static size_type priv_get_total_units(size_type userbytes);


   bool priv_expand(void *ptr
                   ,const size_type min_size, const size_type preferred_size
                   ,size_type &received_size);


   void* priv_expand_both_sides(boost::interprocess::allocation_type command
                               ,size_type min_size
                               ,size_type preferred_size
                               ,size_type &received_size
                               ,void *reuse_ptr
                               ,bool only_preferred_backwards
                               ,size_type backwards_multiple);


   bool priv_is_prev_allocated(block_ctrl *ptr);


   static block_ctrl * priv_end_block(block_ctrl *first_segment_block);


   static block_ctrl * priv_first_block(block_ctrl *end_segment_block);


   static block_ctrl * priv_prev_block(block_ctrl *ptr);


   static block_ctrl * priv_next_block(block_ctrl *ptr);


   bool priv_is_allocated_block(block_ctrl *ptr);


   void priv_mark_as_allocated_block(block_ctrl *ptr);


   void priv_mark_new_allocated_block(block_ctrl *ptr)
   { return priv_mark_as_allocated_block(ptr); }


   void priv_mark_as_free_block(block_ctrl *ptr);



   void* priv_check_and_allocate(size_type units
                                ,block_ctrl* block
                                ,size_type &received_size);

   void priv_deallocate(void *addr);


   void priv_add_segment(void *addr, size_type size);

   public:

   static const size_type Alignment = !MemAlignment
      ? size_type(::boost::alignment_of< ::boost::detail::max_align>::value)
      : size_type(MemAlignment)
      ;

   private:

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((Alignment >= 4)) == 0 ? false : true) >)> boost_static_assert_typedef_350;

   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((Alignment >= ::boost::alignment_of<void_pointer>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_352;
   static const size_type AlignmentMask = (Alignment - 1);
   static const size_type BlockCtrlBytes = ipcdetail::ct_rounded_size<sizeof(block_ctrl), Alignment>::value;
   static const size_type BlockCtrlUnits = BlockCtrlBytes/Alignment;
   static const size_type AllocatedCtrlBytes = ipcdetail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
   static const size_type AllocatedCtrlUnits = AllocatedCtrlBytes/Alignment;
   static const size_type EndCtrlBlockBytes = ipcdetail::ct_rounded_size<sizeof(SizeHolder), Alignment>::value;
   static const size_type EndCtrlBlockUnits = EndCtrlBlockBytes/Alignment;
   static const size_type MinBlockUnits = BlockCtrlUnits;
   static const size_type UsableByPreviousChunk = sizeof(size_type);


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((0 == (Alignment & (Alignment - size_type(1u))))) == 0 ? false : true) >)> boost_static_assert_typedef_364;

   public:
   static const size_type PayloadPerAllocation = AllocatedCtrlBytes - UsableByPreviousChunk;
};



template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
       rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
   ::priv_first_block_offset_from_this(const void *this_ptr, size_type extra_hdr_bytes)
{
   size_type uint_this = (std::size_t)this_ptr;
   size_type main_hdr_end = uint_this + sizeof(rbtree_best_fit) + extra_hdr_bytes;
   size_type aligned_main_hdr_end = ipcdetail::get_rounded_size(main_hdr_end, Alignment);
   size_type block1_off = aligned_main_hdr_end - uint_this;
   algo_impl_t::assert_alignment(aligned_main_hdr_end);
   algo_impl_t::assert_alignment(uint_this + block1_off);
   return block1_off;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   priv_add_segment(void *addr, size_type size)
{

   algo_impl_t::check_alignment(addr);

   ((size >= (BlockCtrlBytes + EndCtrlBlockBytes)) ? static_cast<void> (0) : __assert_fail ("size >= (BlockCtrlBytes + EndCtrlBlockBytes)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 393, __PRETTY_FUNCTION__));


   block_ctrl *first_big_block = new(addr)block_ctrl;
   first_big_block->m_size = size/Alignment - EndCtrlBlockUnits;
   ((first_big_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("first_big_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 398, __PRETTY_FUNCTION__));


   block_ctrl *end_block = static_cast<block_ctrl*>
      (new (reinterpret_cast<char*>(addr) + first_big_block->m_size*Alignment)SizeHolder);


   priv_mark_as_free_block (first_big_block);




   first_big_block->m_prev_size = end_block->m_size =
      (reinterpret_cast<char*>(end_block) - reinterpret_cast<char*>(first_big_block))/Alignment;

   end_block->m_allocated = 1;
   first_big_block->m_prev_allocated = 1;

   ((priv_next_block(first_big_block) == end_block) ? static_cast<void> (0) : __assert_fail ("priv_next_block(first_big_block) == end_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 416, __PRETTY_FUNCTION__));
   ((priv_prev_block(end_block) == first_big_block) ? static_cast<void> (0) : __assert_fail ("priv_prev_block(end_block) == first_big_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 417, __PRETTY_FUNCTION__));
   ((priv_first_block() == first_big_block) ? static_cast<void> (0) : __assert_fail ("priv_first_block() == first_big_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 418, __PRETTY_FUNCTION__));
   ((priv_end_block() == end_block) ? static_cast<void> (0) : __assert_fail ("priv_end_block() == end_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 419, __PRETTY_FUNCTION__));





   ((static_cast<void*>(static_cast<SizeHolder*>(first_big_block)) < static_cast<void*>(static_cast<TreeHook*>(first_big_block))) ? static_cast<void> (0) : __assert_fail ("static_cast<void*>(static_cast<SizeHolder*>(first_big_block)) < static_cast<void*>(static_cast<TreeHook*>(first_big_block))",
 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp"
# 425 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 3 4
   ,
 426
# 425 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 3 4
   , __PRETTY_FUNCTION__))
                                                                        ;

   m_header.m_imultiset.insert(*first_big_block);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
       rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
   ::priv_first_block()
{
   size_type block1_off = priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
   return reinterpret_cast<block_ctrl *>(reinterpret_cast<char*>(this) + block1_off);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
       rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>
   ::priv_end_block()
{
   size_type block1_off = priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
   const size_type original_first_block_size = m_header.m_size/Alignment*Alignment - block1_off/Alignment*Alignment - EndCtrlBlockBytes;
   block_ctrl *end_block = reinterpret_cast<block_ctrl*>
      (reinterpret_cast<char*>(this) + block1_off + original_first_block_size);
   return end_block;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   rbtree_best_fit(size_type size, size_type extra_hdr_bytes)
{

   m_header.m_allocated = 0;
   m_header.m_size = size;
   m_header.m_extra_hdr_bytes = extra_hdr_bytes;



   ((get_min_size(extra_hdr_bytes) <= size) ? static_cast<void> (0) : __assert_fail ("get_min_size(extra_hdr_bytes) <= size", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 463, __PRETTY_FUNCTION__));
   size_type block1_off = priv_first_block_offset_from_this(this, extra_hdr_bytes);
   priv_add_segment(reinterpret_cast<char*>(this) + block1_off, size - block1_off);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::~rbtree_best_fit()
{



}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::grow(size_type extra_size)
{

   block_ctrl *first_block = priv_first_block();
   block_ctrl *old_end_block = priv_end_block();
   size_type old_border_offset = (size_type)(reinterpret_cast<char*>(old_end_block) -
                                    reinterpret_cast<char*>(this)) + EndCtrlBlockBytes;


   m_header.m_size += extra_size;


   if((m_header.m_size - old_border_offset) < MinBlockUnits){
      return;
   }


   size_type align_offset = (m_header.m_size - old_border_offset)/Alignment;
   block_ctrl *new_end_block = reinterpret_cast<block_ctrl*>
      (reinterpret_cast<char*>(old_end_block) + align_offset*Alignment);




   new_end_block->m_allocated = 1;




   new_end_block->m_size = (reinterpret_cast<char*>(new_end_block) -
                                 reinterpret_cast<char*>(first_block))/Alignment;

   first_block->m_prev_size = new_end_block->m_size;
   first_block->m_prev_allocated = 1;
   ((new_end_block == priv_end_block()) ? static_cast<void> (0) : __assert_fail ("new_end_block == priv_end_block()", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 511, __PRETTY_FUNCTION__));


   block_ctrl *new_block = old_end_block;
   new_block->m_size = (reinterpret_cast<char*>(new_end_block) -
                        reinterpret_cast<char*>(new_block))/Alignment;
   ((new_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("new_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 517, __PRETTY_FUNCTION__));
   priv_mark_as_allocated_block(new_block);
   ((priv_next_block(new_block) == new_end_block) ? static_cast<void> (0) : __assert_fail ("priv_next_block(new_block) == new_end_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 519, __PRETTY_FUNCTION__));

   m_header.m_allocated += (size_type)new_block->m_size*Alignment;


   this->priv_deallocate(priv_get_user_buffer(new_block));
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::shrink_to_fit()
{

   block_ctrl *first_block = priv_first_block();
   algo_impl_t::assert_alignment(first_block);


   block_ctrl *old_end_block = priv_end_block();
   algo_impl_t::assert_alignment(old_end_block);
   size_type old_end_block_size = old_end_block->m_size;

   void *unique_buffer = 0;
   block_ctrl *last_block;

   if(priv_next_block(first_block) == old_end_block){

      size_type ignore;
      unique_buffer = priv_allocate(boost::interprocess::allocate_new, 0, 0, ignore).first;

      if(!unique_buffer)
         return;

      algo_impl_t::assert_alignment(unique_buffer);
      block_ctrl *unique_block = priv_get_block(unique_buffer);
      ((priv_is_allocated_block(unique_block)) ? static_cast<void> (0) : __assert_fail ("priv_is_allocated_block(unique_block)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 552, __PRETTY_FUNCTION__));
      algo_impl_t::assert_alignment(unique_block);
      last_block = priv_next_block(unique_block);
      ((!priv_is_allocated_block(last_block)) ? static_cast<void> (0) : __assert_fail ("!priv_is_allocated_block(last_block)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 555, __PRETTY_FUNCTION__));
      algo_impl_t::assert_alignment(last_block);
   }
   else{

      if(priv_is_prev_allocated(old_end_block))
         return;

      last_block = priv_prev_block(old_end_block);
   }

   size_type last_block_size = last_block->m_size;


   m_header.m_imultiset.erase(Imultiset::s_iterator_to(*last_block));

   size_type shrunk_border_offset = (size_type)(reinterpret_cast<char*>(last_block) -
                                       reinterpret_cast<char*>(this)) + EndCtrlBlockBytes;

   block_ctrl *new_end_block = last_block;
   algo_impl_t::assert_alignment(new_end_block);






   new_end_block->m_size = first_block->m_prev_size =
      (reinterpret_cast<char*>(new_end_block) - reinterpret_cast<char*>(first_block))/Alignment;


   new_end_block->m_allocated = 1;
   (void)last_block_size;
   (void)old_end_block_size;
   ((new_end_block->m_size == (old_end_block_size - last_block_size)) ? static_cast<void> (0) : __assert_fail ("new_end_block->m_size == (old_end_block_size - last_block_size)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 589, __PRETTY_FUNCTION__));


   m_header.m_size = shrunk_border_offset;
   ((priv_end_block() == new_end_block) ? static_cast<void> (0) : __assert_fail ("priv_end_block() == new_end_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 593, __PRETTY_FUNCTION__));
   if(unique_buffer)
      priv_deallocate(unique_buffer);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_size() const
{ return m_header.m_size; }

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::get_free_memory() const
{
   return m_header.m_size - m_header.m_allocated -
      priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   get_min_size (size_type extra_hdr_bytes)
{
   return (algo_impl_t::ceil_units(sizeof(rbtree_best_fit)) +
           algo_impl_t::ceil_units(extra_hdr_bytes) +
           MinBlockUnits + EndCtrlBlockUnits)*Alignment;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
    all_memory_deallocated()
{

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   size_type block1_off =
      priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);

   return m_header.m_allocated == 0 &&
      m_header.m_imultiset.begin() != m_header.m_imultiset.end() &&
       (++m_header.m_imultiset.begin()) == m_header.m_imultiset.end()
       && m_header.m_imultiset.begin()->m_size ==
         (m_header.m_size - block1_off - EndCtrlBlockBytes)/Alignment;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
    check_sanity()
{

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   imultiset_iterator ib(m_header.m_imultiset.begin()), ie(m_header.m_imultiset.end());

   size_type free_memory = 0;


   for(; ib != ie; ++ib){
      free_memory += (size_type)ib->m_size*Alignment;
      algo_impl_t::assert_alignment(&*ib);
      if(!algo_impl_t::check_alignment(&*ib))
         return false;
   }


   if(m_header.m_allocated > m_header.m_size){
      return false;
   }

   size_type block1_off =
      priv_first_block_offset_from_this(this, m_header.m_extra_hdr_bytes);


   if(free_memory > (m_header.m_size - block1_off)){
      return false;
   }
   return true;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   allocate(size_type nbytes)
{

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   size_type ignore;
   void * ret = priv_allocate(boost::interprocess::allocate_new, nbytes, nbytes, ignore).first;
   return ret;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   allocate_aligned(size_type nbytes, size_type alignment)
{

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   return algo_impl_t::allocate_aligned(this, nbytes, alignment);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
template<class T>
inline std::pair<T*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
                        size_type preferred_size,size_type &received_size,
                        T *reuse_ptr)
{
   std::pair<void*, bool> ret = priv_allocation_command
      (command, limit_size, preferred_size, received_size, static_cast<void*>(reuse_ptr), sizeof(T));

   ((0 == ((std::size_t)ret.first % ::boost::alignment_of<T>::value)) ? static_cast<void> (0) : __assert_fail ("0 == ((std::size_t)ret.first % ::boost::alignment_of<T>::value)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 704, __PRETTY_FUNCTION__));
   return std::pair<T *, bool>(static_cast<T*>(ret.first), ret.second);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline std::pair<void*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   raw_allocation_command (boost::interprocess::allocation_type command, size_type limit_objects,
                        size_type preferred_objects,size_type &received_objects,
                        void *reuse_ptr, size_type sizeof_object)
{
   if(!sizeof_object)
      return std::pair<void *, bool>(static_cast<void*>(0), false);
   if(command & boost::interprocess::try_shrink_in_place){
      bool success = algo_impl_t::try_shrink
         ( this, reuse_ptr, limit_objects*sizeof_object
         , preferred_objects*sizeof_object, received_objects);
      received_objects /= sizeof_object;
      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
   }
   return priv_allocation_command
      (command, limit_objects, preferred_objects, received_objects, reuse_ptr, sizeof_object);
}


template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline std::pair<void*, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   priv_allocation_command (boost::interprocess::allocation_type command, size_type limit_size,
                       size_type preferred_size,size_type &received_size,
                       void *reuse_ptr, size_type sizeof_object)
{
   std::pair<void*, bool> ret;
   size_type max_count = m_header.m_size/sizeof_object;
   if(limit_size > max_count || preferred_size > max_count){
      ret.first = 0; return ret;
   }
   size_type l_size = limit_size*sizeof_object;
   size_type p_size = preferred_size*sizeof_object;
   size_type r_size;
   {

      boost::interprocess::scoped_lock<mutex_type> guard(m_header);

      ret = priv_allocate(command, l_size, p_size, r_size, reuse_ptr, sizeof_object);
   }
   received_size = r_size/sizeof_object;
   return ret;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   size(const void *ptr) const
{



   return ((size_type)priv_get_block(ptr)->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::zero_free_memory()
{

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   imultiset_iterator ib(m_header.m_imultiset.begin()), ie(m_header.m_imultiset.end());


   while(ib != ie){

      volatile char *ptr = reinterpret_cast<char*>(&*ib) + BlockCtrlBytes;
      size_type s = (size_type)ib->m_size*Alignment - BlockCtrlBytes;
      while(s--){
         *ptr++ = 0;
      }





      ++ib;
   }
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   priv_expand_both_sides(boost::interprocess::allocation_type command
                         ,size_type min_size
                         ,size_type preferred_size
                         ,size_type &received_size
                         ,void *reuse_ptr
                         ,bool only_preferred_backwards
                         ,size_type backwards_multiple)
{
   algo_impl_t::assert_alignment(reuse_ptr);
   if(command & boost::interprocess::expand_fwd){
      if(priv_expand(reuse_ptr, min_size, preferred_size, received_size))
         return reuse_ptr;
   }
   else{
      received_size = this->size(reuse_ptr);
      if(received_size >= preferred_size || received_size >= min_size)
         return reuse_ptr;
   }

   if(backwards_multiple){
      ((0 == (min_size % backwards_multiple)) ? static_cast<void> (0) : __assert_fail ("0 == (min_size % backwards_multiple)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 810, __PRETTY_FUNCTION__));
      ((0 == (preferred_size % backwards_multiple)) ? static_cast<void> (0) : __assert_fail ("0 == (preferred_size % backwards_multiple)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 811, __PRETTY_FUNCTION__));
   }

   if(command & boost::interprocess::expand_bwd){

      block_ctrl *reuse = priv_get_block(reuse_ptr);



      algo_impl_t::assert_alignment(reuse);

      block_ctrl *prev_block;


      if(priv_is_prev_allocated(reuse)){
         return 0;
      }

      prev_block = priv_prev_block(reuse);
      ((!priv_is_allocated_block(prev_block)) ? static_cast<void> (0) : __assert_fail ("!priv_is_allocated_block(prev_block)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 830, __PRETTY_FUNCTION__));


      ((prev_block->m_size == reuse->m_prev_size) ? static_cast<void> (0) : __assert_fail ("prev_block->m_size == reuse->m_prev_size", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 833, __PRETTY_FUNCTION__));
      algo_impl_t::assert_alignment(prev_block);

      size_type needs_backwards_aligned;
      size_type lcm;
      if(!algo_impl_t::calculate_lcm_and_needs_backwards_lcmed
         ( backwards_multiple
         , received_size
         , only_preferred_backwards ? preferred_size : min_size
         , lcm, needs_backwards_aligned)){
         return 0;
      }


      if(size_type(prev_block->m_size*Alignment) >= needs_backwards_aligned){

         if(command & boost::interprocess::expand_fwd){
            size_type received_size2;
            if(!priv_expand(reuse_ptr, received_size, received_size, received_size2)){
               ((0) ? static_cast<void> (0) : __assert_fail ("0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 852, __PRETTY_FUNCTION__));
            }
            ((received_size = received_size2) ? static_cast<void> (0) : __assert_fail ("received_size = received_size2", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 854, __PRETTY_FUNCTION__));
         }

         if(prev_block->m_size >= (needs_backwards_aligned/Alignment + BlockCtrlUnits)){
            block_ctrl *new_block = reinterpret_cast<block_ctrl *>
               (reinterpret_cast<char*>(reuse) - needs_backwards_aligned);


            new_block->m_size =
               AllocatedCtrlUnits + (needs_backwards_aligned + (received_size - UsableByPreviousChunk))/Alignment;
            ((new_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("new_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 864, __PRETTY_FUNCTION__));
            priv_mark_as_allocated_block(new_block);

            prev_block->m_size = (reinterpret_cast<char*>(new_block) -
                                  reinterpret_cast<char*>(prev_block))/Alignment;
            ((prev_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("prev_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 869, __PRETTY_FUNCTION__));
            priv_mark_as_free_block(prev_block);




            {
               imultiset_iterator prev_block_it(Imultiset::s_iterator_to(*prev_block));
               imultiset_iterator was_smaller_it(prev_block_it);
               if(prev_block_it != m_header.m_imultiset.begin() &&
                  (--(was_smaller_it = prev_block_it))->m_size > prev_block->m_size){
                  m_header.m_imultiset.erase(prev_block_it);
                  m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *prev_block);
               }
            }

            received_size = needs_backwards_aligned + received_size;
            m_header.m_allocated += needs_backwards_aligned;


            algo_impl_t::assert_alignment(new_block);



            void *p = priv_get_user_buffer(new_block);
            void *user_ptr = reinterpret_cast<char*>(p);
            (((static_cast<char*>(reuse_ptr) - static_cast<char*>(user_ptr)) % backwards_multiple == 0) ? static_cast<void> (0) : __assert_fail ("(static_cast<char*>(reuse_ptr) - static_cast<char*>(user_ptr)) % backwards_multiple == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 895, __PRETTY_FUNCTION__));
            algo_impl_t::assert_alignment(user_ptr);
            return user_ptr;
         }


         else if(prev_block->m_size >= needs_backwards_aligned/Alignment &&
                 0 == ((prev_block->m_size*Alignment) % lcm)) {

            m_header.m_imultiset.erase(Imultiset::s_iterator_to(*prev_block));



            received_size = received_size + (size_type)prev_block->m_size*Alignment;

            m_header.m_allocated += (size_type)prev_block->m_size*Alignment;

            prev_block->m_size = prev_block->m_size + reuse->m_size;
            ((prev_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("prev_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 913, __PRETTY_FUNCTION__));
            priv_mark_as_allocated_block(prev_block);



            void *user_ptr = priv_get_user_buffer(prev_block);
            (((static_cast<char*>(reuse_ptr) - static_cast<char*>(user_ptr)) % backwards_multiple == 0) ? static_cast<void> (0) : __assert_fail ("(static_cast<char*>(reuse_ptr) - static_cast<char*>(user_ptr)) % backwards_multiple == 0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 919, __PRETTY_FUNCTION__));
            algo_impl_t::assert_alignment(user_ptr);
            return user_ptr;
         }
         else{

         }
      }
   }
   return 0;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   deallocate_many(typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::multiallocation_chain chain)
{

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   algo_impl_t::deallocate_many(this, boost::move(chain));
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
std::pair<void *, bool> rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   priv_allocate(boost::interprocess::allocation_type command
                ,size_type limit_size
                ,size_type preferred_size
                ,size_type &received_size
                ,void *reuse_ptr
               ,size_type backwards_multiple)
{



   if(command & boost::interprocess::shrink_in_place){
      bool success =
         algo_impl_t::shrink(this, reuse_ptr, limit_size, preferred_size, received_size);
      return std::pair<void *, bool> ((success ? reuse_ptr : 0), true);
   }

   typedef std::pair<void *, bool> return_type;
   received_size = 0;

   if(limit_size > preferred_size)
      return return_type(static_cast<void*>(0), false);


   size_type preferred_units = priv_get_total_units(preferred_size);


   size_type limit_units = priv_get_total_units(limit_size);


   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
      void *ret = priv_expand_both_sides
         (command, limit_size, preferred_size, received_size, reuse_ptr, true, backwards_multiple);
      if(ret)
         return return_type(ret, true);
   }

   if(command & boost::interprocess::allocate_new){
      size_block_ctrl_compare comp;
      imultiset_iterator it(m_header.m_imultiset.lower_bound(preferred_units, comp));

      if(it != m_header.m_imultiset.end()){
         return return_type(this->priv_check_and_allocate
            (preferred_units, ipcdetail::to_raw_pointer(&*it), received_size), false);
      }

      if(it != m_header.m_imultiset.begin()&&
              (--it)->m_size >= limit_units){
         return return_type(this->priv_check_and_allocate
            (it->m_size, ipcdetail::to_raw_pointer(&*it), received_size), false);
      }
   }



   if(reuse_ptr && (command & (boost::interprocess::expand_fwd | boost::interprocess::expand_bwd))){
      return return_type(priv_expand_both_sides
         (command, limit_size, preferred_size, received_size, reuse_ptr, false, backwards_multiple), true);
   }

   return return_type(static_cast<void*>(0), false);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_get_block(const void *ptr)
{
   return const_cast<block_ctrl*>
      (reinterpret_cast<const block_ctrl*>
         (reinterpret_cast<const char*>(ptr) - AllocatedCtrlBytes));
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline
void *rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
      priv_get_user_buffer(const typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{ return const_cast<char*>(reinterpret_cast<const char*>(block) + AllocatedCtrlBytes); }

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
inline typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::size_type
rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   priv_get_total_units(size_type userbytes)
{
   if(userbytes < UsableByPreviousChunk)
      userbytes = UsableByPreviousChunk;
   size_type units = ipcdetail::get_rounded_size(userbytes - UsableByPreviousChunk, Alignment)/Alignment + AllocatedCtrlUnits;
   if(units < BlockCtrlUnits) units = BlockCtrlUnits;
   return units;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::
   priv_expand (void *ptr
               ,const size_type min_size
               ,const size_type preferred_size
               ,size_type &received_size)
{

   block_ctrl *block = priv_get_block(ptr);
   size_type old_block_units = block->m_size;


   ((priv_is_allocated_block(block)) ? static_cast<void> (0) : __assert_fail ("priv_is_allocated_block(block)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1045, __PRETTY_FUNCTION__));



   received_size = (old_block_units - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
   if(received_size >= preferred_size || received_size >= min_size)
      return true;


   const size_type min_user_units = algo_impl_t::ceil_units(min_size - UsableByPreviousChunk);
   const size_type preferred_user_units = algo_impl_t::ceil_units(preferred_size - UsableByPreviousChunk);


   ((min_user_units <= preferred_user_units) ? static_cast<void> (0) : __assert_fail ("min_user_units <= preferred_user_units", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1058, __PRETTY_FUNCTION__));

   block_ctrl *next_block;

   if(priv_is_allocated_block(next_block = priv_next_block(block))){
      return received_size >= min_size ? true : false;
   }
   algo_impl_t::assert_alignment(next_block);


   const size_type merged_units = old_block_units + (size_type)next_block->m_size;


   const size_type merged_user_units = merged_units - AllocatedCtrlUnits;

   if(merged_user_units < min_user_units){
      received_size = merged_units*Alignment - UsableByPreviousChunk;
      return false;
   }


   size_type intended_user_units = (merged_user_units < preferred_user_units) ?
      merged_user_units : preferred_user_units;


   const size_type intended_units = AllocatedCtrlUnits + intended_user_units;


   if((merged_units - intended_units) >= BlockCtrlUnits){



      ((next_block->m_size == priv_next_block(next_block)->m_prev_size) ? static_cast<void> (0) : __assert_fail ("next_block->m_size == priv_next_block(next_block)->m_prev_size", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1090, __PRETTY_FUNCTION__));
      const size_type rem_units = merged_units - intended_units;
# 1100 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp"
      imultiset_iterator old_next_block_it(Imultiset::s_iterator_to(*next_block));
      const bool size_invariants_broken =
            (next_block->m_size - rem_units ) < BlockCtrlUnits ||
            (old_next_block_it != m_header.m_imultiset.begin() &&
            (--imultiset_iterator(old_next_block_it))->m_size > rem_units);
      if(size_invariants_broken){
         m_header.m_imultiset.erase(old_next_block_it);
      }

      block_ctrl *rem_block = new(reinterpret_cast<block_ctrl*>
                     (reinterpret_cast<char*>(block) + intended_units*Alignment))block_ctrl;
      rem_block->m_size = rem_units;
      algo_impl_t::assert_alignment(rem_block);
      ((rem_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("rem_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1113, __PRETTY_FUNCTION__));
      priv_mark_as_free_block(rem_block);


      if(size_invariants_broken)
         m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *rem_block);
      else
         m_header.m_imultiset.replace_node(old_next_block_it, *rem_block);


      block->m_size = intended_user_units + AllocatedCtrlUnits;
      ((block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1124, __PRETTY_FUNCTION__));
      m_header.m_allocated += (intended_units - old_block_units)*Alignment;
   }

   else{

      m_header.m_imultiset.erase(Imultiset::s_iterator_to(*next_block));


      block->m_size = merged_units;
      ((block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1134, __PRETTY_FUNCTION__));
      m_header.m_allocated += (merged_units - old_block_units)*Alignment;
   }
   priv_mark_as_allocated_block(block);
   received_size = ((size_type)block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;
   return true;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_prev_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *ptr)
{
   ((!ptr->m_prev_allocated) ? static_cast<void> (0) : __assert_fail ("!ptr->m_prev_allocated", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1147, __PRETTY_FUNCTION__));
   return reinterpret_cast<block_ctrl *>
      (reinterpret_cast<char*>(ptr) - ptr->m_prev_size*Alignment);
}



template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_end_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *first_segment_block)
{


   ((first_segment_block->m_prev_allocated) ? static_cast<void> (0) : __assert_fail ("first_segment_block->m_prev_allocated", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1161, __PRETTY_FUNCTION__));
   block_ctrl *end_block = reinterpret_cast<block_ctrl *>
      (reinterpret_cast<char*>(first_segment_block) + first_segment_block->m_prev_size*Alignment);
   (void)end_block;
   ((end_block->m_allocated == 1) ? static_cast<void> (0) : __assert_fail ("end_block->m_allocated == 1", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1165, __PRETTY_FUNCTION__));
   ((end_block->m_size == first_segment_block->m_prev_size) ? static_cast<void> (0) : __assert_fail ("end_block->m_size == first_segment_block->m_prev_size", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1166, __PRETTY_FUNCTION__));
   ((end_block > first_segment_block) ? static_cast<void> (0) : __assert_fail ("end_block > first_segment_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1167, __PRETTY_FUNCTION__));
   return end_block;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_first_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *end_segment_block)
{


   ((end_segment_block->m_allocated) ? static_cast<void> (0) : __assert_fail ("end_segment_block->m_allocated", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1178, __PRETTY_FUNCTION__));
   block_ctrl *first_block = reinterpret_cast<block_ctrl *>
      (reinterpret_cast<char*>(end_segment_block) - end_segment_block->m_size*Alignment);
   (void)first_block;
   ((first_block->m_prev_allocated == 1) ? static_cast<void> (0) : __assert_fail ("first_block->m_prev_allocated == 1", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1182, __PRETTY_FUNCTION__));
   ((first_block->m_prev_size == end_segment_block->m_size) ? static_cast<void> (0) : __assert_fail ("first_block->m_prev_size == end_segment_block->m_size", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1183, __PRETTY_FUNCTION__));
   ((end_segment_block > first_block) ? static_cast<void> (0) : __assert_fail ("end_segment_block > first_block", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1184, __PRETTY_FUNCTION__));
   return first_block;
}


template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *
   rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_next_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *ptr)
{
   return reinterpret_cast<block_ctrl *>
      (reinterpret_cast<char*>(ptr) + ptr->m_size*Alignment);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_is_allocated_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
   bool allocated = block->m_allocated != 0;

   if(block != priv_end_block()){
      block_ctrl *next_block = reinterpret_cast<block_ctrl *>
         (reinterpret_cast<char*>(block) + block->m_size*Alignment);
      bool next_block_prev_allocated = next_block->m_prev_allocated != 0;
      (void)next_block_prev_allocated;
      ((allocated == next_block_prev_allocated) ? static_cast<void> (0) : __assert_fail ("allocated == next_block_prev_allocated", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1209, __PRETTY_FUNCTION__));
   }
   else{
      block = block;
   }

   return allocated;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
bool rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_is_prev_allocated
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
   if(block->m_prev_allocated){
      return true;
   }
   else{

      if(block != priv_first_block()){
         block_ctrl *prev = priv_prev_block(block);
         (void)prev;
         ((!prev->m_allocated) ? static_cast<void> (0) : __assert_fail ("!prev->m_allocated", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1230, __PRETTY_FUNCTION__));
      }
      else{
         block = block;
      }

      return false;
   }
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_mark_as_allocated_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
   block->m_allocated = 1;
   reinterpret_cast<block_ctrl *>
      (reinterpret_cast<char*>(block)+ block->m_size*Alignment)->m_prev_allocated = 1;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_mark_as_free_block
      (typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl *block)
{
   block->m_allocated = 0;
   block_ctrl *next_block = priv_next_block(block);
   next_block->m_prev_allocated = 0;
   next_block->m_prev_size = block->m_size;
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment> inline
void* rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_check_and_allocate
   (size_type nunits
   ,typename rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::block_ctrl* block
   ,size_type &received_size)
{
   size_type upper_nunits = nunits + BlockCtrlUnits;
   imultiset_iterator it_old = Imultiset::s_iterator_to(*block);
   algo_impl_t::assert_alignment(block);

   if (block->m_size >= upper_nunits){



      size_type block_old_size = block->m_size;
      block->m_size = nunits;
      ((block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1275, __PRETTY_FUNCTION__));


      block_ctrl *rem_block = new(reinterpret_cast<block_ctrl*>
                     (reinterpret_cast<char*>(block) + Alignment*nunits))block_ctrl;
      algo_impl_t::assert_alignment(rem_block);
      rem_block->m_size = block_old_size - nunits;
      ((rem_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("rem_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1282, __PRETTY_FUNCTION__));
      priv_mark_as_free_block(rem_block);

      imultiset_iterator it_hint;
      if(it_old == m_header.m_imultiset.begin()
         || (--imultiset_iterator(it_old))->m_size < rem_block->m_size){






         m_header.m_imultiset.replace_node(Imultiset::s_iterator_to(*it_old), *rem_block);
      }
      else{

         m_header.m_imultiset.erase(it_old);
         m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *rem_block);
      }

   }
   else if (block->m_size >= nunits){
      m_header.m_imultiset.erase(it_old);
   }
   else{
      ((0) ? static_cast<void> (0) : __assert_fail ("0", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1307, __PRETTY_FUNCTION__));
      return 0;
   }


   m_header.m_allocated += (size_type)block->m_size*Alignment;
   received_size = ((size_type)block->m_size - AllocatedCtrlUnits)*Alignment + UsableByPreviousChunk;


   priv_mark_as_allocated_block(block);



   TreeHook *t = static_cast<TreeHook*>(block);

   std::size_t tree_hook_offset_in_block = (char*)t - (char*)block;

   char *ptr = reinterpret_cast<char*>(block)+tree_hook_offset_in_block;
   const std::size_t s = BlockCtrlBytes - tree_hook_offset_in_block;
   std::memset(ptr, 0, s);
   this->priv_next_block(block)->m_prev_size = 0;
   return priv_get_user_buffer(block);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::deallocate(void* addr)
{
   if(!addr) return;

   boost::interprocess::scoped_lock<mutex_type> guard(m_header);

   return this->priv_deallocate(addr);
}

template<class MutexFamily, class VoidPointer, std::size_t MemAlignment>
void rbtree_best_fit<MutexFamily, VoidPointer, MemAlignment>::priv_deallocate(void* addr)
{
   if(!addr) return;

   block_ctrl *block = priv_get_block(addr);


   ((priv_is_allocated_block(block)) ? static_cast<void> (0) : __assert_fail ("priv_is_allocated_block(block)", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1349, __PRETTY_FUNCTION__));



   algo_impl_t::assert_alignment(addr);

   size_type block_old_size = Alignment*(size_type)block->m_size;
   ((m_header.m_allocated >= block_old_size) ? static_cast<void> (0) : __assert_fail ("m_header.m_allocated >= block_old_size", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1356, __PRETTY_FUNCTION__));


   m_header.m_allocated -= block_old_size;


   block_ctrl *block_to_insert = block;


   block_ctrl *next_block = priv_next_block(block);
   bool merge_with_prev = !priv_is_prev_allocated(block);
   bool merge_with_next = !priv_is_allocated_block(next_block);


   if(merge_with_prev || merge_with_next){

      if(merge_with_prev){

         block_ctrl *prev_block = priv_prev_block(block);
         prev_block->m_size += block->m_size;
         ((prev_block->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("prev_block->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1376, __PRETTY_FUNCTION__));
         block_to_insert = prev_block;
      }

      if(merge_with_next){
         block_to_insert->m_size += next_block->m_size;
         ((block_to_insert->m_size >= BlockCtrlUnits) ? static_cast<void> (0) : __assert_fail ("block_to_insert->m_size >= BlockCtrlUnits", "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp", 1382, __PRETTY_FUNCTION__));
         if(merge_with_prev)
            m_header.m_imultiset.erase(Imultiset::s_iterator_to(*next_block));
      }

      bool only_merge_next = !merge_with_prev && merge_with_next;
      imultiset_iterator free_block_to_check_it
         (Imultiset::s_iterator_to(only_merge_next ? *next_block : *block_to_insert));
      imultiset_iterator was_bigger_it(free_block_to_check_it);



      if(++was_bigger_it != m_header.m_imultiset.end() &&
         block_to_insert->m_size > was_bigger_it->m_size ){
         m_header.m_imultiset.erase(free_block_to_check_it);
         m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *block_to_insert);
      }
      else if(only_merge_next){
         m_header.m_imultiset.replace_node(free_block_to_check_it, *block_to_insert);
      }
   }
   else{
      m_header.m_imultiset.insert(m_header.m_imultiset.begin(), *block_to_insert);
   }
   priv_mark_as_free_block(block_to_insert);
}



}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 1415 "/opt/sevenflow/boost/include/boost/interprocess/mem_algo/rbtree_best_fit.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 35 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 2



# 1 "/usr/include/errno.h" 1 3 4
# 39 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/ptime_to_timespec.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/ptime_to_timespec.hpp"
namespace boost {

namespace interprocess {

namespace ipcdetail {

inline timespec ptime_to_timespec (const boost::posix_time::ptime &tm)
{
   const boost::posix_time::ptime epoch(boost::gregorian::date(1970,1,1));
   boost::posix_time::time_duration duration (tm - epoch);
   timespec ts;
   ts.tv_sec = duration.total_seconds();
   ts.tv_nsec = duration.total_nanoseconds() % 1000000000;
   return ts;
}

}

}

}
# 41 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/pthread_helpers.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/pthread_helpers.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/pthread_helpers.hpp" 2



# 1 "/usr/include/errno.h" 1 3 4
# 23 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/pthread_helpers.hpp" 2


namespace boost {
namespace interprocess {
namespace ipcdetail{




   struct mutexattr_wrapper
   {

      mutexattr_wrapper(bool recursive = false)
      {
         if(pthread_mutexattr_init(&m_attr)!=0 ||
            pthread_mutexattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0 ||
             (recursive &&
              pthread_mutexattr_settype(&m_attr, PTHREAD_MUTEX_RECURSIVE)!= 0 ))
            throw interprocess_exception("pthread_mutexattr_xxxx failed");
      }


     ~mutexattr_wrapper() { pthread_mutexattr_destroy(&m_attr); }


      operator pthread_mutexattr_t&() { return m_attr; }

      pthread_mutexattr_t m_attr;
   };


   struct condattr_wrapper
   {

      condattr_wrapper()
      {
         if(pthread_condattr_init(&m_attr)!=0 ||
            pthread_condattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0)
            throw interprocess_exception("pthread_condattr_xxxx failed");
      }


     ~condattr_wrapper() { pthread_condattr_destroy(&m_attr); }


      operator pthread_condattr_t&(){ return m_attr; }

      pthread_condattr_t m_attr;
   };


   class mutex_initializer
   {
    public:

      mutex_initializer(pthread_mutex_t &mut, pthread_mutexattr_t &mut_attr)
      : mp_mut(&mut)
      {
         if(pthread_mutex_init(mp_mut, &mut_attr) != 0)
            throw interprocess_exception("pthread_mutex_init failed");
      }

     ~mutex_initializer() { if(mp_mut) pthread_mutex_destroy(mp_mut); }

      void release() {mp_mut = 0; }

    private:
      pthread_mutex_t *mp_mut;
   };


   class condition_initializer
   {
    public:
      condition_initializer(pthread_cond_t &cond, pthread_condattr_t &cond_attr)
      : mp_cond(&cond)
      {
         if(pthread_cond_init(mp_cond, &cond_attr)!= 0)
            throw interprocess_exception("pthread_cond_init failed");
      }

     ~condition_initializer() { if(mp_cond) pthread_cond_destroy(mp_cond); }

      void release() { mp_cond = 0; }

    private:
      pthread_cond_t *mp_cond;
   };






   struct barrierattr_wrapper
   {

      barrierattr_wrapper()
      {
         if(pthread_barrierattr_init(&m_attr)!=0 ||
            pthread_barrierattr_setpshared(&m_attr, PTHREAD_PROCESS_SHARED)!= 0)
            throw interprocess_exception("pthread_barrierattr_xxx failed");
      }


     ~barrierattr_wrapper() { pthread_barrierattr_destroy(&m_attr); }


      operator pthread_barrierattr_t&() { return m_attr; }

      pthread_barrierattr_t m_attr;
   };


   class barrier_initializer
   {
    public:

      barrier_initializer(pthread_barrier_t &mut,
                          pthread_barrierattr_t &mut_attr,
                          int count)
      : mp_barrier(&mut)
      {
         if(pthread_barrier_init(mp_barrier, &mut_attr, count) != 0)
            throw interprocess_exception("pthread_barrier_init failed");
      }

     ~barrier_initializer() { if(mp_barrier) pthread_barrier_destroy(mp_barrier); }

      void release() {mp_barrier = 0; }

    private:
      pthread_barrier_t *mp_barrier;
   };



}

}

}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 167 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/pthread_helpers.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 49 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 2

namespace boost {
namespace interprocess {
namespace ipcdetail {

class posix_condition;

class posix_mutex
{
   posix_mutex(const posix_mutex &);
   posix_mutex &operator=(const posix_mutex &);
   public:

   posix_mutex();
   ~posix_mutex();

   void lock();
   bool try_lock();
   bool timed_lock(const boost::posix_time::ptime &abs_time);
   void unlock();

   friend class posix_condition;

   private:
   pthread_mutex_t m_mut;
};

inline posix_mutex::posix_mutex()
{
   mutexattr_wrapper mut_attr;
   mutex_initializer mut(m_mut, mut_attr);
   mut.release();
}

inline posix_mutex::~posix_mutex()
{
   int res = pthread_mutex_destroy(&m_mut);
   ((res == 0) ? static_cast<void> (0) : __assert_fail ("res == 0", "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp", 86, __PRETTY_FUNCTION__));(void)res;
}

inline void posix_mutex::lock()
{
   if (pthread_mutex_lock(&m_mut) != 0)
      throw lock_exception();
}

inline bool posix_mutex::try_lock()
{
   int res = pthread_mutex_trylock(&m_mut);
   if (!(res == 0 || res == 16))
      throw lock_exception();
   return res == 0;
}

inline bool posix_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
{
   if(abs_time == boost::posix_time::pos_infin){
      this->lock();
      return true;
   }


   timespec ts = ptime_to_timespec(abs_time);
   int res = pthread_mutex_timedlock(&m_mut, &ts);
   if (res != 0 && res != 110)
      throw lock_exception();
   return res == 0;
# 137 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp"
}

inline void posix_mutex::unlock()
{
   int res = 0;
   res = pthread_mutex_unlock(&m_mut);
   ((res == 0) ? static_cast<void> (0) : __assert_fail ("res == 0", "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp", 143, __PRETTY_FUNCTION__));
}

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 151 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/mutex.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp" 2
# 59 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp"
namespace boost {
namespace interprocess {

class interprocess_condition;



class interprocess_mutex
{


   interprocess_mutex(const interprocess_mutex &);
   interprocess_mutex &operator=(const interprocess_mutex &);
   friend class interprocess_condition;

   public:



   interprocess_mutex();



   ~interprocess_mutex();






   void lock();






   bool try_lock();
# 105 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp"
   bool timed_lock(const boost::posix_time::ptime &abs_time);



   void unlock();

   private:
# 120 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp"
      ipcdetail::posix_mutex mutex;







};

}
}


namespace boost {
namespace interprocess {

inline interprocess_mutex::interprocess_mutex(){}

inline interprocess_mutex::~interprocess_mutex(){}

inline void interprocess_mutex::lock()
{
# 152 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp"
      mutex.lock();

}

inline bool interprocess_mutex::try_lock()
{ return mutex.try_lock(); }

inline bool interprocess_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
{ return mutex.timed_lock(abs_time); }

inline void interprocess_mutex::unlock()
{ mutex.unlock(); }

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 169 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_mutex.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp" 1
# 36 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 40 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp" 1
# 30 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp" 2



# 1 "/usr/include/errno.h" 1 3 4
# 35 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 43 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp" 2

namespace boost {
namespace interprocess {
namespace ipcdetail {

class posix_recursive_mutex
{
   posix_recursive_mutex(const posix_recursive_mutex &);
   posix_recursive_mutex &operator=(const posix_recursive_mutex &);
   public:

   posix_recursive_mutex();
   ~posix_recursive_mutex();

   void lock();
   bool try_lock();
   bool timed_lock(const boost::posix_time::ptime &abs_time);
   void unlock();

   private:
   pthread_mutex_t m_mut;
};

inline posix_recursive_mutex::posix_recursive_mutex()
{
   mutexattr_wrapper mut_attr(true);
   mutex_initializer mut(m_mut, mut_attr);
   mut.release();
}

inline posix_recursive_mutex::~posix_recursive_mutex()
{
   int res = pthread_mutex_destroy(&m_mut);
   ((res == 0) ? static_cast<void> (0) : __assert_fail ("res == 0", "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp", 76, __PRETTY_FUNCTION__));(void)res;
}

inline void posix_recursive_mutex::lock()
{
   if (pthread_mutex_lock(&m_mut) != 0)
      throw lock_exception();
}

inline bool posix_recursive_mutex::try_lock()
{
   int res = pthread_mutex_trylock(&m_mut);
   if (!(res == 0 || res == 16))
      throw lock_exception();
   return res == 0;
}

inline bool posix_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
{
   if(abs_time == boost::posix_time::pos_infin){
      this->lock();
      return true;
   }


   timespec ts = ptime_to_timespec(abs_time);
   int res = pthread_mutex_timedlock(&m_mut, &ts);
   if (res != 0 && res != 110)
      throw lock_exception();
   return res == 0;
# 127 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp"
}

inline void posix_recursive_mutex::unlock()
{
   int res = 0;
   res = pthread_mutex_unlock(&m_mut);
   ((res == 0) ? static_cast<void> (0) : __assert_fail ("res == 0", "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp", 133, __PRETTY_FUNCTION__));
}

}
}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 141 "/opt/sevenflow/boost/include/boost/interprocess/sync/posix/recursive_mutex.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp" 2
# 72 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp"
namespace boost {
namespace interprocess {




class interprocess_recursive_mutex
{


   interprocess_recursive_mutex(const interprocess_recursive_mutex &);
   interprocess_recursive_mutex &operator=(const interprocess_recursive_mutex &);

   public:


   interprocess_recursive_mutex();



  ~interprocess_recursive_mutex();







   void lock();





   bool try_lock();





   bool timed_lock(const boost::posix_time::ptime &abs_time);





   void unlock();

   private:
# 129 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp"
      ipcdetail::posix_recursive_mutex mutex;







};

}
}

namespace boost {
namespace interprocess {

inline interprocess_recursive_mutex::interprocess_recursive_mutex(){}

inline interprocess_recursive_mutex::~interprocess_recursive_mutex(){}

inline void interprocess_recursive_mutex::lock()
{
# 159 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp"
      mutex.lock();

}

inline bool interprocess_recursive_mutex::try_lock()
{ return mutex.try_lock(); }

inline bool interprocess_recursive_mutex::timed_lock(const boost::posix_time::ptime &abs_time)
{ return mutex.timed_lock(abs_time); }

inline void interprocess_recursive_mutex::unlock()
{ mutex.unlock(); }

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 176 "/opt/sevenflow/boost/include/boost/interprocess/sync/interprocess_recursive_mutex.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/interprocess/sync/null_mutex.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/interprocess/sync/null_mutex.hpp"
# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_begin.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/interprocess/sync/null_mutex.hpp" 2






namespace boost {

namespace posix_time
{ class ptime; }

namespace interprocess {



class null_mutex
{

   null_mutex(const null_mutex&);
   null_mutex &operator= (const null_mutex&);

   public:



   null_mutex(){}



   ~null_mutex(){}


   void lock(){}



   bool try_lock()
   { return true; }



   bool timed_lock(const boost::posix_time::ptime &)
   { return true; }



   void unlock(){}



   void lock_sharable(){}



   bool try_lock_sharable()
   { return true; }



   bool timed_lock_sharable(const boost::posix_time::ptime &)
   { return true; }



   void unlock_sharable(){}



   void lock_upgradable(){}



   bool try_lock_upgradable()
   { return true; }



   bool timed_lock_upgradable(const boost::posix_time::ptime &)
   { return true; }



   void unlock_upgradable(){}



   void unlock_and_lock_upgradable(){}



   void unlock_and_lock_sharable(){}



   void unlock_upgradable_and_lock_sharable(){}





   void unlock_upgradable_and_lock(){}



   bool try_unlock_upgradable_and_lock()
   { return true; }



   bool timed_unlock_upgradable_and_lock(const boost::posix_time::ptime &)
   { return true; }



   bool try_unlock_sharable_and_lock()
   { return true; }



   bool try_unlock_sharable_and_lock_upgradable()
   { return true; }
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 146 "/opt/sevenflow/boost/include/boost/interprocess/sync/null_mutex.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp" 2




namespace boost {

namespace interprocess {



struct mutex_family
{
   typedef boost::interprocess::interprocess_mutex mutex_type;
   typedef boost::interprocess::interprocess_recursive_mutex recursive_mutex_type;
};



struct null_mutex_family
{
   typedef boost::interprocess::null_mutex mutex_type;
   typedef boost::interprocess::null_mutex recursive_mutex_type;
};

}

}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 53 "/opt/sevenflow/boost/include/boost/interprocess/sync/mutex_family.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2

namespace boost {

namespace interprocess {




template
      <
         class CharType,
         class AllocationAlgorithm,
         template<class IndexConfig> class IndexType
      >
class basic_managed_shared_memory
   : public ipcdetail::basic_managed_memory_impl
      <CharType, AllocationAlgorithm, IndexType
      ,ipcdetail::managed_open_or_create_impl<shared_memory_object
                                             , AllocationAlgorithm::Alignment>::ManagedOpenOrCreateUserOffset>
   , private ipcdetail::managed_open_or_create_impl<shared_memory_object
                                                   , AllocationAlgorithm::Alignment>
{

   typedef ipcdetail::basic_managed_memory_impl
      <CharType, AllocationAlgorithm, IndexType,
      ipcdetail::managed_open_or_create_impl
         < shared_memory_object, AllocationAlgorithm::Alignment>::ManagedOpenOrCreateUserOffset> base_t;
   typedef ipcdetail::managed_open_or_create_impl
      <shared_memory_object, AllocationAlgorithm::Alignment> base2_t;

   typedef ipcdetail::create_open_func<base_t> create_open_func_t;

   basic_managed_shared_memory *get_this_pointer()
   { return this; }

   public:
   typedef shared_memory_object device_type;
   typedef typename base_t::size_type size_type;

   private:
   typedef typename base_t::char_ptr_holder_t char_ptr_holder_t;
   private: basic_managed_shared_memory(basic_managed_shared_memory &); basic_managed_shared_memory& operator=(basic_managed_shared_memory &); public: operator ::boost::rv<basic_managed_shared_memory>&() { return *static_cast< ::boost::rv<basic_managed_shared_memory>* >(this); } operator const ::boost::rv<basic_managed_shared_memory>&() const { return *static_cast<const ::boost::rv<basic_managed_shared_memory>* >(this); } private:


   public:







   ~basic_managed_shared_memory()
   {}



   basic_managed_shared_memory()
   {}



   basic_managed_shared_memory(create_only_t create_only, const char *name,
                             size_type size, const void *addr = 0, const permissions& perm = permissions())
      : base_t()
      , base2_t(create_only, name, size, read_write, addr,
                create_open_func_t(get_this_pointer(), ipcdetail::DoCreate), perm)
   {}





   basic_managed_shared_memory (open_or_create_t open_or_create,
                              const char *name, size_type size,
                              const void *addr = 0, const permissions& perm = permissions())
      : base_t()
      , base2_t(open_or_create, name, size, read_write, addr,
                create_open_func_t(get_this_pointer(),
                ipcdetail::DoOpenOrCreate), perm)
   {}




   basic_managed_shared_memory (open_copy_on_write_t, const char* name,
                                const void *addr = 0)
      : base_t()
      , base2_t(open_only, name, copy_on_write, addr,
                create_open_func_t(get_this_pointer(),
                ipcdetail::DoOpen))
   {}




   basic_managed_shared_memory (open_read_only_t, const char* name,
                                const void *addr = 0)
      : base_t()
      , base2_t(open_only, name, read_only, addr,
                create_open_func_t(get_this_pointer(),
                ipcdetail::DoOpen))
   {}



   basic_managed_shared_memory (open_only_t open_only, const char* name,
                                const void *addr = 0)
      : base_t()
      , base2_t(open_only, name, read_write, addr,
                create_open_func_t(get_this_pointer(),
                ipcdetail::DoOpen))
   {}



   basic_managed_shared_memory(::boost::rv< basic_managed_shared_memory >& moved)
   {
      basic_managed_shared_memory tmp;
      this->swap(moved);
      tmp.swap(moved);
   }



   basic_managed_shared_memory &operator=(::boost::rv< basic_managed_shared_memory >& moved)
   {
      basic_managed_shared_memory tmp(boost::move(moved));
      this->swap(tmp);
      return *this;
   }



   void swap(basic_managed_shared_memory &other)
   {
      base_t::swap(other);
      base2_t::swap(other);
   }






   static bool grow(const char *shmname, size_type extra_bytes)
   {
      return base_t::template grow
         <basic_managed_shared_memory>(shmname, extra_bytes);
   }





   static bool shrink_to_fit(const char *shmname)
   {
      return base_t::template shrink_to_fit
         <basic_managed_shared_memory>(shmname);
   }





   template <class T>
   std::pair<T*, size_type> find (char_ptr_holder_t name)
   {
      if(base2_t::get_mapped_region().get_mode() == read_only){
         return base_t::template find_no_lock<T>(name);
      }
      else{
         return base_t::template find<T>(name);
      }
   }


};

}
}

# 1 "/opt/sevenflow/boost/include/boost/interprocess/detail/config_end.hpp" 1
# 213 "/opt/sevenflow/boost/include/boost/interprocess/managed_shared_memory.hpp" 2
# 2 "test.cpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
# 1 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_never_true.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 18 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp" 2



namespace boost{

namespace detail{






namespace allocator{






template<typename Type>
class partial_std_allocator_wrapper:public std::allocator<Type>
{
public:





  typedef Type value_type;

  partial_std_allocator_wrapper(){};

  template<typename Other>
  partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){}

  partial_std_allocator_wrapper(const std::allocator<Type>& x):
    std::allocator<Type>(x)
  {
  };
# 70 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp"
};
# 101 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp"
template<typename Allocator>
struct is_partial_std_allocator
{
  static const bool value=false;
};





template<typename Allocator,typename Type>
struct partial_std_allocator_rebind_to
{
  typedef partial_std_allocator_wrapper<Type> type;
};
# 142 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp"
template<typename Allocator>
struct rebinder
{
  template<typename Type>
  struct result
  {
      typedef typename Allocator::template
          rebind<Type>::other other;
  };
};


template<typename Allocator,typename Type>
struct compliant_allocator_rebind_to
{
  typedef typename rebinder<Allocator>::
      template result<Type>::other type;
};



template<typename Allocator,typename Type>
struct rebind_to:
  mpl::eval_if_c<
    is_partial_std_allocator<Allocator>::value,
    partial_std_allocator_rebind_to<Allocator,Type>,
    compliant_allocator_rebind_to<Allocator,Type>
  >
{
};



template<typename Type>
void construct(void* p,const Type& t)
{
  new (p) Type(t);
}
# 190 "/opt/sevenflow/boost/include/boost/detail/allocator_utilities.hpp"
template<typename Type>
void destroy(const Type* p)
{




  p->~Type();


}





}

}

}
# 21 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/at.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/at.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/at_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/at_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct at_impl;
template< typename Sequence, typename N > struct at;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/at.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/at_impl.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/at_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/begin_end.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/begin_end.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/begin_end_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/begin_end_fwd.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/begin_end.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag_fwd.hpp"
namespace boost { namespace mpl {

struct nested_begin_end_tag;
struct non_sequence_tag;

template< typename Sequence > struct sequence_tag;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/void.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/void.hpp"
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> { }; }

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_begin.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_begin.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/has_xxx.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/has_xxx.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/type_wrapper.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/type_wrapper.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/has_xxx.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/yes_no.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/yes_no.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/arrays.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/yes_no.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/aux_/yes_no.hpp"
}}}
# 23 "/opt/sevenflow/boost/include/boost/mpl/has_xxx.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/has_xxx.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/has_xxx.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/msvc_typename.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/mpl/has_xxx.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_begin.hpp" 2

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; };
}}}
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/traits_lambda_spec.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp" 2


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 "/opt/sevenflow/boost/include/boost/mpl/aux_/begin_end_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/begin_end.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_tag.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_tag.hpp"
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; };
}}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp"
namespace boost { namespace mpl { namespace aux {
# 62 "/opt/sevenflow/boost/include/boost/mpl/aux_/is_msvc_eti_arg.hpp"
}}}
# 22 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag.hpp" 2




namespace boost { namespace mpl {
# 78 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag.hpp"
namespace aux {

template< bool has_tag_, bool has_begin_ >
struct sequence_tag_impl
{


    template< typename Sequence > struct result2_;
};
# 98 "/opt/sevenflow/boost/include/boost/mpl/sequence_tag.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/begin_end.hpp" 2



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

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/at_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/advance_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/advance_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/common_name_wknd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/advance_fwd.hpp" 2

namespace boost { namespace mpl {



template< typename Tag > struct advance_impl;
template< typename Iterator, typename N > struct advance;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/less.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/less.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/numeric_cast.hpp" 1
# 30 "/opt/sevenflow/boost/include/boost/mpl/numeric_cast.hpp"
namespace boost { namespace mpl {



template< typename SourceTag, typename TargetTag > struct numeric_cast
{
    template< typename N > struct apply;
};

}}
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_apply.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_apply.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/has_apply.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_apply.hpp" 2

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 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/tag.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/tag.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/tag.hpp"
};

}}
# 25 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/forwarding.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2

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 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp"
    };
};

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 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_cast_utils.hpp"
    };
};

}}}
# 26 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_eti_base.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_eti_base.hpp"
namespace boost { namespace mpl { namespace aux {
# 55 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_eti_base.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/less.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/less.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/negate.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/negate.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/negate.hpp"
template<>
struct negate_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (-N::value) >

    {
    };
};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/long.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/long.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/long_fwd.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/long_fwd.hpp"
namespace mpl_ {

template< long N > struct long_;

}
namespace boost { namespace mpl { using ::mpl_::long_; } }
# 18 "/opt/sevenflow/boost/include/boost/mpl/long.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp" 1
# 40 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/integral_wrapper.hpp"
    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 "/opt/sevenflow/boost/include/boost/mpl/long.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_forward.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_forward.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/next.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/next.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/next_prior.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/next_prior.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/next.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_forward.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_forward.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_forward.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_forward.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_backward.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_backward.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/prior.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_backward.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_backward.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_backward.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/mpl/aux_/advance_backward.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/mpl/advance.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/aux_/at_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/deref.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/deref.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_type.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_type.hpp"
namespace boost { namespace mpl { namespace aux {
# 48 "/opt/sevenflow/boost/include/boost/mpl/aux_/msvc_type.hpp"
template< typename T > struct msvc_type
{
    typedef typename T::type type;
};

template<> struct msvc_type<int>
{
    typedef int type;
};



}}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/deref.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/aux_/at_impl.hpp" 2


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 "/opt/sevenflow/boost/include/boost/mpl/at.hpp" 2






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

}}
# 24 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/contains.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/contains.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/contains_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/contains_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct contains_impl;
template< typename Sequence, typename T > struct contains;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/contains.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/contains_impl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/contains_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/find.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/find.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/find_if.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/find_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/find_if_pred.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/mpl/aux_/find_if_pred.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_apply.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_apply.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_fwd.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/mpl/apply_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/mpl/apply_fwd.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/arg_fwd.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/arg_fwd.hpp"
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_assert.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_assert.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp" 1
# 29 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/pp_counter.hpp" 1
# 30 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp" 2





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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 36 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp" 2
# 62 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp"
namespace mpl_ {

struct failed {};
# 75 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/assert.hpp"
}
# 24 "/opt/sevenflow/boost/include/boost/mpl/aux_/na_assert.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/arity_spec.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/arg_typedef.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 38 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp" 2
# 43 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/lambda.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/lambda.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/bind_fwd.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/bind_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/bind.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/mpl/bind_fwd.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/mpl/bind_fwd.hpp" 2
# 24 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/protect.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/protect.hpp"
namespace boost { namespace mpl {

template<
      typename T = na
    , int not_le_ = 0
    >
struct protect : T
{



    typedef protect type;

};
# 48 "/opt/sevenflow/boost/include/boost/mpl/protect.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 2
# 50 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 51 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/mpl/lambda.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/bind_fwd.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/quote.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/quote.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_type.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_type.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/quote.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/bcc.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/quote.hpp" 2
# 45 "/opt/sevenflow/boost/include/boost/mpl/quote.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 46 "/opt/sevenflow/boost/include/boost/mpl/quote.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/template_arity.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/mpl/aux_/template_arity.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/mpl/aux_/template_arity.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 45 "/opt/sevenflow/boost/include/boost/mpl/aux_/full_lambda.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/lambda.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_apply.hpp" 2


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 "/opt/sevenflow/boost/include/boost/mpl/aux_/find_if_pred.hpp" 2


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 "/opt/sevenflow/boost/include/boost/mpl/find_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/find_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/logical.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/logical.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/or.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/mpl/or.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/or.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 44 "/opt/sevenflow/boost/include/boost/mpl/or.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/mpl/logical.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/always.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/always.hpp"
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;
    };
};



}}
# 21 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/pair.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/pair.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/mpl/iter_fold_if.hpp" 2







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 "/opt/sevenflow/boost/include/boost/mpl/find_if.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/find.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/same_as.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/same_as.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/lambda_spec.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/same_as.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/find.hpp" 2



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 "/opt/sevenflow/boost/include/boost/mpl/aux_/contains_impl.hpp" 2







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 "/opt/sevenflow/boost/include/boost/mpl/aux_/contains_impl.hpp"
    };
};

 template<> struct contains_impl<non_sequence_tag> {};

}}
# 21 "/opt/sevenflow/boost/include/boost/mpl/contains.hpp" 2



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

}}
# 25 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/size.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/size.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/size_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/size_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct size_impl;
template< typename Sequence > struct size;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/size.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/size_impl.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/size_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/distance_fwd.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/distance_fwd.hpp"
namespace boost { namespace mpl {



template< typename Tag > struct distance_impl;
template< typename First, typename Last > struct distance;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/iter_fold.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/iter_fold.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/O1_size.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/O1_size.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/O1_size_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/O1_size_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct O1_size_impl;
template< typename Sequence > struct O1_size;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/O1_size.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/O1_size_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_size.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_size.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/O1_size_impl.hpp" 2





namespace boost { namespace mpl {
# 35 "/opt/sevenflow/boost/include/boost/mpl/aux_/O1_size_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/O1_size_impl.hpp"
    };
};
# 85 "/opt/sevenflow/boost/include/boost/mpl/aux_/O1_size_impl.hpp"
}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/O1_size.hpp" 2



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 "/opt/sevenflow/boost/include/boost/mpl/iter_fold.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 2
# 33 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/mpl/aux_/iter_fold_impl.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/mpl/iter_fold.hpp" 2



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 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/iterator_range.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/iterator_range.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp" 2







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 "/opt/sevenflow/boost/include/boost/mpl/distance.hpp"
    };
};

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 "/opt/sevenflow/boost/include/boost/mpl/aux_/size_impl.hpp" 2



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 "/opt/sevenflow/boost/include/boost/mpl/size.hpp" 2




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

}}
# 29 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/multi_index_container_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index_container_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/identity.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/multi_index/identity.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/identity_fwd.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/multi_index/identity_fwd.hpp"
namespace boost{

namespace multi_index{

template<class Type> struct identity;

}

}
# 19 "/opt/sevenflow/boost/include/boost/multi_index/identity.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/multi_index/identity.hpp"
namespace boost{

template<class Type> class reference_wrapper;

namespace multi_index{

namespace detail{
# 55 "/opt/sevenflow/boost/include/boost/multi_index/identity.hpp"
template<typename Type>
struct const_identity_base
{
  typedef Type result_type;

  template<typename ChainedPtr>


  typename disable_if<is_convertible<const ChainedPtr&,Type&>,Type&>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  Type& operator()(Type& x)const
  {
    return x;
  }

  Type& operator()(const reference_wrapper<Type>& x)const
  {
    return x.get();
  }

  Type& operator()(
    const reference_wrapper<typename remove_const<Type>::type>& x,int=0)const
  {
    return x.get();
  }
};

template<typename Type>
struct non_const_identity_base
{
  typedef Type result_type;



  template<typename ChainedPtr>


  typename disable_if<
    is_convertible<const ChainedPtr&,const Type&>,Type&>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  const Type& operator()(const Type& x,int=0)const
  {
    return x;
  }

  Type& operator()(Type& x)const
  {
    return x;
  }

  const Type& operator()(const reference_wrapper<const Type>& x,int=0)const
  {
    return x.get();
  }

  Type& operator()(const reference_wrapper<Type>& x)const
  {
    return x.get();
  }
};

}

template<class Type>
struct identity:
  mpl::if_c<
    is_const<Type>::value,
    detail::const_identity_base<Type>,detail::non_const_identity_base<Type>
  >::type
{
};

}

}
# 18 "/opt/sevenflow/boost/include/boost/multi_index_container_fwd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/indexed_by.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/indexed_by.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/limits/vector.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/vector20.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/vector20.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/vector10.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/vector10.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/at.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/at.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/tag.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/tag.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/typeof.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/tag.hpp" 2


namespace boost { namespace mpl { namespace aux {

struct v_iter_tag;


struct vector_tag;




}}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/at.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/at.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/at.hpp"
}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/front.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/front.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/front_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct front_impl;
template< typename Sequence > struct front;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/front.hpp" 2






namespace boost { namespace mpl {



template<>
struct front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : v_at<Vector,0>
    {
    };
};
# 54 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/front.hpp"
}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_front.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_front.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/push_front_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/push_front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct push_front_impl;
template< typename Sequence, typename T > struct push_front;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_front.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/item.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/item.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_front.hpp" 2


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 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/pop_front.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/pop_front.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/pop_front_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/pop_front_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct pop_front_impl;
template< typename Sequence > struct pop_front;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/pop_front.hpp" 2







namespace boost { namespace mpl {

template<>
struct pop_front_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,1> type;
    };
};

}}
# 21 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_back.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_back.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/push_back_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/push_back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct push_back_impl;
template< typename Sequence, typename T > struct push_back;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/push_back.hpp" 2







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 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/pop_back.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/pop_back.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/pop_back_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/pop_back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct pop_back_impl;
template< typename Sequence > struct pop_back;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/pop_back.hpp" 2







namespace boost { namespace mpl {

template<>
struct pop_back_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef v_mask<Vector,0> type;
    };
};

}}
# 23 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/back.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/back.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/back_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/back_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct back_impl;
template< typename Sequence > struct back;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/back.hpp" 2






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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/back.hpp"
}}
# 24 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/clear.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/clear.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/clear_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/clear_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct clear_impl;
template< typename Sequence > struct clear;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/clear.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/vector0.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/vector0.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/iterator_tags.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/iterator_tags.hpp"
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; };

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/plus.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/plus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/largest_int.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/largest_int.hpp"
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
        >
{






};

}}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/plus.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/plus.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/minus.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/minus.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/minus.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/mpl/aux_/arithmetic_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/minus.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp"
};




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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/iterator.hpp"
}}
# 23 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/vector0.hpp" 2



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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/vector0.hpp"
};

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/clear.hpp" 2




namespace boost { namespace mpl {



template<>
struct clear_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
    {
        typedef vector0<> type;
    };
};
# 53 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/clear.hpp"
}}
# 25 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/O1_size.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/O1_size.hpp"
namespace boost { namespace mpl {



template<>
struct O1_size_impl< aux::vector_tag >
{
    template< typename Vector > struct apply
        : Vector::size
    {
    };
};
# 54 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/O1_size.hpp"
}}
# 26 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/size.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/size.hpp"
namespace boost { namespace mpl {



template<>
struct size_impl< aux::vector_tag >
    : O1_size_impl< aux::vector_tag >
{
};
# 47 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/size.hpp"
}}
# 27 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/empty.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/empty.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/empty_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/empty_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct empty_impl;
template< typename Sequence > struct empty;

}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/empty.hpp" 2






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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/empty.hpp"
}}
# 28 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/begin_end.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/begin_end.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/vector/vector0.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector/vector10.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/mpl/vector/vector10.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/vector/vector10.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/mpl/vector/vector20.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/mpl/vector/vector20.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/vector/aux_/include_preprocessed.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/vector/vector20.hpp" 2
# 37 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp" 2
# 46 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/vector.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 47 "/opt/sevenflow/boost/include/boost/mpl/vector.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/multi_index/indexed_by.hpp" 2
# 51 "/opt/sevenflow/boost/include/boost/multi_index/indexed_by.hpp"
namespace boost{

namespace multi_index{

template<
  typename T0 , typename T1 =mpl::na , typename T2 =mpl::na , typename T3 =mpl::na , typename T4 =mpl::na , typename T5 =mpl::na , typename T6 =mpl::na , typename T7 =mpl::na , typename T8 =mpl::na , typename T9 =mpl::na , typename T10 =mpl::na , typename T11 =mpl::na , typename T12 =mpl::na , typename T13 =mpl::na , typename T14 =mpl::na , typename T15 =mpl::na , typename T16 =mpl::na , typename T17 =mpl::na , typename T18 =mpl::na , typename T19 =mpl::na


>
struct indexed_by:
  mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>
{
};

}

}
# 19 "/opt/sevenflow/boost/include/boost/multi_index_container_fwd.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/ordered_index_fwd.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/multi_index/ordered_index_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/ord_index_args.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/ord_index_args.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/no_duplicate_tags.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/detail/no_duplicate_tags.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/fold.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/fold.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/fold_impl.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/fold_impl.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/mpl/aux_/fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/mpl/aux_/fold_impl.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/mpl/fold.hpp" 2



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

}}
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/no_duplicate_tags.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/at_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/at_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/has_key_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/has_key_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/tag.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/tag.hpp"
namespace boost { namespace mpl { namespace aux {

struct set_tag;

}}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/has_key_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/has_key_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/has_key_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct has_key_impl;
template< typename AssociativeSequence, typename Key > struct has_key;

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/has_key_impl.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/overload_names.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/aux_/overload_names.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/ptr_to_ref.hpp" 1
# 40 "/opt/sevenflow/boost/include/boost/mpl/aux_/ptr_to_ref.hpp"
namespace boost { namespace mpl { namespace aux {

template< typename T > static T const& ptr_to_ref(T*);

}}}
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/overload_names.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/config/operators.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/overload_names.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/has_key_impl.hpp" 2






namespace boost { namespace mpl {

template<>
struct has_key_impl< aux::set_tag >
{
    template< typename Set, typename T > struct apply
# 47 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/has_key_impl.hpp"
        : bool_<
              ( sizeof( Set::is_masked_( aux::ptr_to_ref(static_cast<Set*>(0)), static_cast<aux::type_wrapper<T>*>(0) )


                    ) == sizeof(aux::no_tag) )
            >
    {

    };
};

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/at_impl.hpp" 2




namespace boost { namespace mpl {

template<>
struct at_impl< aux::set_tag >
{
    template< typename Set, typename T > struct apply
    {
        typedef typename if_<
              has_key_impl<aux::set_tag>::apply<Set,T>
            , T
            , void_
            >::type type;
    };
};

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/clear_impl.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/clear_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/set0.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/set0.hpp"
namespace boost { namespace mpl {
# 53 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/set0.hpp"
template< typename Dummy = na > struct set0
{
    typedef set0<> item_;
    typedef item_ type;
    typedef aux::set_tag tag;
    typedef void_ last_masked_;
    typedef void_ item_type_;
    typedef long_<0> size;
    typedef long_<1> order;

    static aux::no_tag order_by_key_(set0<> const&, void const volatile*);
    static aux::yes_tag is_masked_(set0<> const&, void const volatile*);
};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/clear_impl.hpp" 2


namespace boost { namespace mpl {

template<>
struct clear_impl< aux::set_tag >
{
    template< typename Set > struct apply
    {
        typedef set0<> type;
    };
};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/size_impl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/size_impl.hpp"
namespace boost { namespace mpl {

template<>
struct size_impl< aux::set_tag >
{
    template< typename Set > struct apply
        : Set::size
    {
    };
};

}}
# 22 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/empty_impl.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/empty_impl.hpp"
namespace boost { namespace mpl {

template<>
struct empty_impl< aux::set_tag >
{
    template< typename Set > struct apply
        : not_< typename Set::size >
    {
    };
};

}}
# 23 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/insert_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/insert_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/insert_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/insert_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct insert_impl;
template< typename Sequence, typename Pos_or_T, typename T > struct insert;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/insert_impl.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/item.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/item.hpp"
namespace boost { namespace mpl {

template< typename T, typename Base >
struct s_item
    : Base
{
    typedef s_item<T,Base> item_;
    typedef void_ last_masked_;
    typedef T item_type_;
    typedef Base base;

    typedef typename next< typename Base::size >::type size;
    typedef typename next< typename Base::order >::type order;




    typedef char (&order_tag_)[order::value];


    static order_tag_ order_by_key_(s_item const&, aux::type_wrapper<T>*); using Base::order_by_key_;
    static aux::no_tag is_masked_(s_item const&, aux::type_wrapper<T>*); using Base::is_masked_;
};


template< typename T, typename Base >
struct s_mask
    : Base
{
    typedef s_mask<T,Base> item_;
    typedef T last_masked_;
    typedef void_ item_type_;
    typedef Base base;
    typedef typename prior< typename Base::size >::type size;

    static aux::yes_tag is_masked_(s_mask const&, aux::type_wrapper<T>*); using Base::is_masked_;
};


template< typename T, typename Base >
struct s_unmask
    : Base
{
    typedef s_unmask<T,Base> item_;
    typedef void_ last_masked_;
    typedef T item_type_;
    typedef Base base;
    typedef typename next< typename Base::size >::type size;

    static aux::no_tag is_masked_(s_unmask const&, aux::type_wrapper<T>*); using Base::is_masked_;
};

}}
# 21 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/insert_impl.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/base.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/base.hpp"
namespace boost { namespace mpl {

template<
      typename T = na
    >
struct base
{
    typedef typename T::base type;
   
};

template<> struct base< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : base< T1 > { }; }; template< typename Tag > struct lambda< base< na > , Tag , int_<-1> > { typedef false_ is_le; typedef base< na > result_; typedef base< na > type; }; namespace aux { template< typename T1 > struct template_arity< base< T1 > > : int_<1> { }; template<> struct template_arity< base< na > > : int_<-1> { }; }

}}
# 24 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/insert_impl.hpp" 2





namespace boost { namespace mpl {

namespace aux {
template< typename Set, typename T > struct set_insert_impl
    : eval_if<
          has_key_impl<aux::set_tag>::apply<Set,T>
        , identity<Set>
        , eval_if<
              is_same< T,typename Set::last_masked_ >
            , base<Set>
            , identity< s_item<T,typename Set::item_> >
            >
        >
{
};
}

template<>
struct insert_impl< aux::set_tag >
{
    template<
          typename Set
        , typename PosOrKey
        , typename KeyOrNA
        >
    struct apply
        : aux::set_insert_impl<
              Set
            , typename if_na<KeyOrNA,PosOrKey>::type
            >
    {
    };
};

}}
# 24 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/erase_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/erase_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct erase_impl;
template< typename Sequence, typename First, typename Last > struct erase;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_impl.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/erase_key_fwd.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/mpl/erase_key_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct erase_key_impl;
template< typename Sequence, typename Key > struct erase_key;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_key_impl.hpp"
namespace boost { namespace mpl {

template<>
struct erase_key_impl< aux::set_tag >
{
    template<
          typename Set
        , typename T
        >
    struct apply
        : eval_if<
              has_key_impl<aux::set_tag>::apply<Set,T>
            , eval_if<
                  is_same< T,typename Set::item_type_ >
                , base<Set>
                , identity< s_mask<T,typename Set::item_> >
                >
            , identity<Set>
            >
    {
    };
};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/erase_impl.hpp" 2


namespace boost { namespace mpl {

template<>
struct erase_impl< aux::set_tag >
{
    template<
          typename Set
        , typename Pos
        , typename unused_
        >
    struct apply
        : erase_key_impl<aux::set_tag>
            ::apply<Set,typename Pos::type>
    {
    };
};

}}
# 25 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/key_type_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/key_type_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/key_type_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/key_type_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct key_type_impl;
template< typename AssociativeSequence, typename T > struct key_type;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/key_type_impl.hpp" 2


namespace boost { namespace mpl {

template<>
struct key_type_impl< aux::set_tag >
{
    template< typename Set, typename T > struct apply
    {
        typedef T type;
    };
};

}}
# 28 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/value_type_impl.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/value_type_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/value_type_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/value_type_fwd.hpp"
namespace boost { namespace mpl {

template< typename Tag > struct value_type_impl;
template< typename AssociativeSequence, typename T > struct value_type;

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/value_type_impl.hpp" 2


namespace boost { namespace mpl {

template<>
struct value_type_impl< aux::set_tag >
{
    template< typename Set, typename T > struct apply
    {
        typedef T type;
    };
};

}}
# 29 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/begin_end_impl.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/begin_end_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/iterator.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/iterator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/has_key.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/has_key.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_key_impl.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/has_key_impl.hpp"
namespace boost { namespace mpl {



template< typename Tag > struct has_key_impl
{
    template< typename AssociativeSequence, typename Key > struct apply;
};

 template<> struct has_key_impl<non_sequence_tag> {};

}}
# 21 "/opt/sevenflow/boost/include/boost/mpl/has_key.hpp" 2



namespace boost { namespace mpl {

template<
      typename AssociativeSequence = na
    , typename Key = na
    >
struct has_key
    : has_key_impl< typename sequence_tag<AssociativeSequence>::type >
        ::template apply<AssociativeSequence,Key>
{
   
};

template<> struct has_key< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_key< T1 , T2 > { }; }; template< typename Tag > struct lambda< has_key< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_key< na , na > result_; typedef has_key< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< has_key< T1 , T2 > > : int_<2> { }; template<> struct template_arity< has_key< na , na > > : int_<-1> { }; }

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/iterator.hpp" 2







namespace boost { namespace mpl {


template< typename Set, typename Tail > struct s_iter;

template< typename Set, typename Tail > struct s_iter_get
    : eval_if<
          has_key< Set,typename Tail::item_type_ >
        , identity< s_iter<Set,Tail> >
        , next< s_iter<Set,Tail> >
        >
{
};

template< typename Set, typename Tail > struct s_iter_impl
{
    typedef Tail tail_;
    typedef forward_iterator_tag category;
    typedef typename Tail::item_type_ type;




};



template< typename Set, typename Tail >
struct next< s_iter<Set,Tail> >
    : s_iter_get< Set,typename Tail::base >
{
};

template< typename Set >
struct next< s_iter<Set,set0<> > >
{
    typedef s_iter<Set,set0<> > type;
};

template< typename Set, typename Tail > struct s_iter
    : s_iter_impl<Set,Tail>
{
};

template< typename Set > struct s_iter<Set, set0<> >
{
    typedef forward_iterator_tag category;
};
# 96 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/iterator.hpp"
}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/set/aux_/begin_end_impl.hpp" 2

namespace boost { namespace mpl {

template<>
struct begin_impl< aux::set_tag >
{
    template< typename Set > struct apply
        : s_iter_get<Set,typename Set::item_>
    {
    };
};

template<>
struct end_impl< aux::set_tag >
{
    template< typename Set > struct apply
    {
        typedef s_iter< Set,set0<> > type;
    };
};

}}
# 30 "/opt/sevenflow/boost/include/boost/mpl/set/set0.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/no_duplicate_tags.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{
# 36 "/opt/sevenflow/boost/include/boost/multi_index/detail/no_duplicate_tags.hpp"
struct duplicate_tag_mark{};

struct duplicate_tag_marker
{
  template <typename MplSet,typename Tag>
  struct apply
  {
    typedef mpl::s_item<
      typename mpl::if_<mpl::has_key<MplSet,Tag>,duplicate_tag_mark,Tag>::type,
      MplSet
    > type;
  };
};

template<typename TagList>
struct no_duplicate_tags
{
  typedef typename mpl::fold<
    TagList,
    mpl::set0<>,
    duplicate_tag_marker
  >::type aux;

  static const bool value=!(mpl::has_key<aux,duplicate_tag_mark>::value)
                                                              ;
};





struct duplicate_tag_list_marker
{
  template <typename MplSet,typename Index>
  struct apply:mpl::fold<
    typename Index::tag_list,
    MplSet,
    duplicate_tag_marker>
  {
  };
};

template<typename IndexList>
struct no_duplicate_tags_in_index_list
{
  typedef typename mpl::fold<
    IndexList,
    mpl::set0<>,
    duplicate_tag_list_marker
  >::type aux;

  static const bool value=!(mpl::has_key<aux,duplicate_tag_mark>::value)
                                                              ;
};

}

}

}
# 18 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/reverse_fold.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/reverse_fold.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/reverse_fold.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_fold_impl.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/mpl/reverse_fold.hpp" 2


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 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/pair_view.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/pair_view.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/iterator_category.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/iterator_category.hpp"
namespace boost { namespace mpl {

template<
      typename Iterator = na
    >
struct iterator_category
{
    typedef typename Iterator::category type;
   
};

template<> struct iterator_category< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_category< T1 > { }; }; template< typename Tag > struct lambda< iterator_category< na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_category< na > result_; typedef iterator_category< na > type; }; namespace aux { template< typename T1 > struct template_arity< iterator_category< T1 > > : int_<1> { }; template<> struct template_arity< iterator_category< na > > : int_<-1> { }; }

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/pair_view.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/mpl/min_max.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/min_max.hpp"
namespace boost { namespace mpl {

template<
      typename N1 = na
    , typename N2 = na
    >
struct min
    : if_< less<N1,N2>,N1,N2 >
{
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct max
    : if_< less<N1,N2>,N2,N1 >
{
};

template<> struct min< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : min< T1 , T2 > { }; }; template< typename Tag > struct lambda< min< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef min< na , na > result_; typedef min< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< min< T1 , T2 > > : int_<2> { }; template<> struct template_arity< min< na , na > > : int_<-1> { }; }
template<> struct max< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : max< T1 , T2 > { }; }; template< typename Tag > struct lambda< max< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef max< na , na > result_; typedef max< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< max< T1 , T2 > > : int_<2> { }; template<> struct template_arity< max< na , na > > : int_<-1> { }; }

}}
# 25 "/opt/sevenflow/boost/include/boost/mpl/pair_view.hpp" 2





namespace boost { namespace mpl {

namespace aux {
struct pair_iter_tag;
# 59 "/opt/sevenflow/boost/include/boost/mpl/pair_view.hpp"
}

template<
      typename Iter1
    , typename Iter2
    , typename Category
    >
struct pair_iter
{
    typedef aux::pair_iter_tag tag;
    typedef Category category;
    typedef Iter1 first;
    typedef Iter2 second;
# 85 "/opt/sevenflow/boost/include/boost/mpl/pair_view.hpp"
};




template< typename Iter1, typename Iter2, typename C >
struct deref< pair_iter<Iter1,Iter2,C> >
{
    typedef pair<
          typename deref<Iter1>::type
        , typename deref<Iter2>::type
        > type;
};

template< typename Iter1, typename Iter2, typename C >
struct next< pair_iter<Iter1,Iter2,C> >
{
    typedef typename mpl::next<Iter1>::type i1_;
    typedef typename mpl::next<Iter2>::type i2_;
    typedef pair_iter<i1_,i2_,C> type;
};

template< typename Iter1, typename Iter2, typename C >
struct prior< pair_iter<Iter1,Iter2,C> >
{
    typedef typename mpl::prior<Iter1>::type i1_;
    typedef typename mpl::prior<Iter2>::type i2_;
    typedef pair_iter<i1_,i2_,C> type;
};




template<> struct advance_impl<aux::pair_iter_tag>
{
    template< typename Iter, typename D > struct apply
    {
        typedef typename mpl::advance< typename Iter::first,D >::type i1_;
        typedef typename mpl::advance< typename Iter::second,D >::type i2_;
        typedef pair_iter<i1_,i2_,typename Iter::category> type;
    };
};

template<> struct distance_impl<aux::pair_iter_tag>
{
    template< typename Iter1, typename Iter2 > struct apply
    {

        typedef typename mpl::distance<
              typename first<Iter1>::type
            , typename first<Iter2>::type
            >::type type;
    };
};


template<
      typename Sequence1 = na
    , typename Sequence2 = na
    >
struct pair_view
{
    typedef nested_begin_end_tag tag;

    typedef typename begin<Sequence1>::type iter1_;
    typedef typename begin<Sequence2>::type iter2_;
    typedef typename min<
          typename iterator_category<iter1_>::type
        , typename iterator_category<iter2_>::type
        >::type category_;

    typedef pair_iter<iter1_,iter2_,category_> begin;

    typedef pair_iter<
          typename end<Sequence1>::type
        , typename end<Sequence2>::type
        , category_
        > end;
};

template<> struct pair_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair_view< na , na > result_; typedef pair_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair_view< na , na > > : int_<-1> { }; }

}}
# 21 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/is_sequence.hpp" 1
# 40 "/opt/sevenflow/boost/include/boost/mpl/is_sequence.hpp"
namespace boost { namespace mpl {
# 90 "/opt/sevenflow/boost/include/boost/mpl/is_sequence.hpp"
template<
      typename T = na
    >
struct is_sequence
    : not_< is_same< typename begin<T>::type, void_ > >
{
   
};
# 108 "/opt/sevenflow/boost/include/boost/mpl/is_sequence.hpp"
template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }

}}
# 22 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/aux_/inserter_algorithm.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/back_inserter.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/back_inserter.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/push_back.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/push_back.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/push_back_impl.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/mpl/aux_/push_back_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/push_back.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/back_inserter.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/inserter.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/inserter.hpp"
namespace boost { namespace mpl {

template<
      typename Sequence
    , typename Operation
    >
struct inserter
{
    typedef Sequence state;
    typedef Operation operation;
};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/back_inserter.hpp" 2

namespace boost {
namespace mpl {

template<
      typename Sequence
    >
struct back_inserter
    : inserter< Sequence,push_back<> >
{
};

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/front_inserter.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/front_inserter.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/push_front.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/push_front.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/push_front_impl.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/mpl/aux_/push_front_impl.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/push_front.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/front_inserter.hpp" 2


namespace boost { namespace mpl {

template<
      typename Sequence
    >
struct front_inserter
    : inserter< Sequence,push_front<> >
{
};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/mpl/clear.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/clear.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/clear_impl.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/aux_/clear_impl.hpp"
namespace boost { namespace mpl {



template< typename Tag >
struct clear_impl
{
    template< typename Sequence > struct apply;
};

 template<> struct clear_impl<non_sequence_tag> {};

}}
# 19 "/opt/sevenflow/boost/include/boost/mpl/clear.hpp" 2




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 "/opt/sevenflow/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2






# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessor/default_params.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/mpl/aux_/inserter_algorithm.hpp" 2
# 29 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp" 2

namespace boost { namespace mpl {

namespace aux {

template<
      typename Seq
    , typename Op
    , typename In
    >
struct transform1_impl
    : fold<
          Seq
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind1< typename lambda<Op>::type, _2>
            >
        >
{
};

template<
      typename Seq
    , typename Op
    , typename In
    >
struct reverse_transform1_impl
    : reverse_fold<
          Seq
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind1< typename lambda<Op>::type, _2>
            >
        >
{
};

template<
      typename Seq1
    , typename Seq2
    , typename Op
    , typename In
    >
struct transform2_impl
    : fold<
          pair_view<Seq1,Seq2>
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind2<
                  typename lambda<Op>::type
                , bind1<first<>,_2>
                , bind1<second<>,_2>
                >
            >
        >
{
};

template<
      typename Seq1
    , typename Seq2
    , typename Op
    , typename In
    >
struct reverse_transform2_impl
    : reverse_fold<
          pair_view<Seq1,Seq2>
        , typename In::state
        , bind2< typename lambda< typename In::operation >::type
            , _1
            , bind2< typename lambda< Op >::type
                , bind1<first<>,_2>
                , bind1<second<>,_2>
                >
            >
        >
{
};

}

 template< typename P1 = na , typename P2 = na , typename P3 = na > struct transform1 : aux::transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct transform1< P1 , P2,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na > struct reverse_transform1 : aux::reverse_transform1_impl< P1 , P2 , P3> { }; template< typename P1 , typename P2 > struct reverse_transform1< P1 , P2,na > : if_< has_push_back<P1> , aux::reverse_transform1_impl< P1 , P2 , back_inserter< typename clear<P1>::type > > , aux::transform1_impl< P1 , P2 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform1< na , na , na > result_; typedef transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< transform1< na , na , na > > : int_<-1> { }; } template<> struct reverse_transform1< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_transform1< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_transform1< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform1< na , na , na > result_; typedef reverse_transform1< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_transform1< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_transform1< na , na , na > > : int_<-1> { }; }
 template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct transform2 : aux::transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct transform2< P1 , P2 , P3,na > : if_< has_push_back< typename clear<P1>::type> , aux::transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::reverse_transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template< typename P1 = na , typename P2 = na , typename P3 = na , typename P4 = na > struct reverse_transform2 : aux::reverse_transform2_impl< P1 , P2 , P3 , P4> { }; template< typename P1 , typename P2 , typename P3 > struct reverse_transform2< P1 , P2 , P3,na > : if_< has_push_back<P1> , aux::reverse_transform2_impl< P1 , P2 , P3 , back_inserter< typename clear<P1>::type > > , aux::transform2_impl< P1 , P2 , P3 , front_inserter< typename clear<P1>::type > > >::type { }; template<> struct transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform2< na , na , na , na > result_; typedef transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform2< na , na , na , na > > : int_<-1> { }; } template<> struct reverse_transform2< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform2< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform2< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform2< na , na , na , na > result_; typedef reverse_transform2< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform2< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform2< na , na , na , na > > : int_<-1> { }; }
# 138 "/opt/sevenflow/boost/include/boost/mpl/transform.hpp"
template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , transform1<Seq1,Seq2OrOperation,OperationOrInserter> , transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef transform< na , na , na , na > result_; typedef transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< transform< na , na , na , na > > : int_<-1> { }; }
template< typename Seq1 = na , typename Seq2OrOperation = na , typename OperationOrInserter = na , typename Inserter = na > struct reverse_transform { typedef typename eval_if< or_< is_na<OperationOrInserter> , is_lambda_expression< Seq2OrOperation > , not_< is_sequence<Seq2OrOperation> > > , reverse_transform1<Seq1,Seq2OrOperation,OperationOrInserter> , reverse_transform2<Seq1,Seq2OrOperation,OperationOrInserter,Inserter> >::type type; }; template<> struct reverse_transform< na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 =na > struct apply : reverse_transform< T1 , T2 , T3 , T4 > { }; }; template< typename Tag > struct lambda< reverse_transform< na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_transform< na , na , na , na > result_; typedef reverse_transform< na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< reverse_transform< T1 , T2 , T3 , T4 > > : int_<4> { }; template<> struct template_arity< reverse_transform< na , na , na , na > > : int_<-1> { }; }



}}
# 20 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/preprocessor/facilities/intercept.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp" 2
# 50 "/opt/sevenflow/boost/include/boost/multi_index/tag.hpp"
namespace boost{

namespace multi_index{

namespace detail{

struct tag_marker{};

template<typename T>
struct is_tag
{
  static const bool value=(is_base_and_derived<tag_marker,T>::value);
};

}

template<
  typename T0 =mpl::na , typename T1 =mpl::na , typename T2 =mpl::na , typename T3 =mpl::na , typename T4 =mpl::na , typename T5 =mpl::na , typename T6 =mpl::na , typename T7 =mpl::na , typename T8 =mpl::na , typename T9 =mpl::na , typename T10 =mpl::na , typename T11 =mpl::na , typename T12 =mpl::na , typename T13 =mpl::na , typename T14 =mpl::na , typename T15 =mpl::na , typename T16 =mpl::na , typename T17 =mpl::na , typename T18 =mpl::na , typename T19 =mpl::na



>
struct tag:private detail::tag_marker
{




  typedef typename mpl::transform<
    mpl::vector< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19>,
    mpl::identity<mpl::_1>
  >::type type;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((detail::no_duplicate_tags<type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_83;
};

}

}
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/ord_index_args.hpp" 2




namespace boost{

namespace multi_index{

namespace detail{
# 43 "/opt/sevenflow/boost/include/boost/multi_index/detail/ord_index_args.hpp"
template<typename KeyFromValue>
struct index_args_default_compare
{
  typedef std::less<typename KeyFromValue::result_type> type;
};

template<typename Arg1,typename Arg2,typename Arg3>
struct ordered_index_args
{
  typedef is_tag<Arg1> full_form;

  typedef typename mpl::if_<
    full_form,
    Arg1,
    tag< > >::type tag_list_type;
  typedef typename mpl::if_<
    full_form,
    Arg2,
    Arg1>::type key_from_value_type;
  typedef typename mpl::if_<
    full_form,
    Arg3,
    Arg2>::type supplied_compare_type;
  typedef typename mpl::eval_if<
    mpl::is_na<supplied_compare_type>,
    index_args_default_compare<key_from_value_type>,
    mpl::identity<supplied_compare_type>
  >::type compare_type;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_tag<tag_list_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_72;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!mpl::is_na<key_from_value_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_73;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!mpl::is_na<compare_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_74;
};

}

}

}
# 17 "/opt/sevenflow/boost/include/boost/multi_index/ordered_index_fwd.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{

template<
  typename KeyFromValue,typename Compare,
  typename SuperMeta,typename TagList,typename Category
>
class ordered_index;

template<
  typename KeyFromValue1,typename Compare1,
  typename SuperMeta1,typename TagList1,typename Category1,
  typename KeyFromValue2,typename Compare2,
  typename SuperMeta2,typename TagList2,typename Category2
>
bool operator==(
  const ordered_index<
    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
  const ordered_index<
    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);

template<
  typename KeyFromValue1,typename Compare1,
  typename SuperMeta1,typename TagList1,typename Category1,
  typename KeyFromValue2,typename Compare2,
  typename SuperMeta2,typename TagList2,typename Category2
>
bool operator<(
  const ordered_index<
    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
  const ordered_index<
    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);

template<
  typename KeyFromValue1,typename Compare1,
  typename SuperMeta1,typename TagList1,typename Category1,
  typename KeyFromValue2,typename Compare2,
  typename SuperMeta2,typename TagList2,typename Category2
>
bool operator!=(
  const ordered_index<
    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
  const ordered_index<
    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);

template<
  typename KeyFromValue1,typename Compare1,
  typename SuperMeta1,typename TagList1,typename Category1,
  typename KeyFromValue2,typename Compare2,
  typename SuperMeta2,typename TagList2,typename Category2
>
bool operator>(
  const ordered_index<
    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
  const ordered_index<
    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);

template<
  typename KeyFromValue1,typename Compare1,
  typename SuperMeta1,typename TagList1,typename Category1,
  typename KeyFromValue2,typename Compare2,
  typename SuperMeta2,typename TagList2,typename Category2
>
bool operator>=(
  const ordered_index<
    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
  const ordered_index<
    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);

template<
  typename KeyFromValue1,typename Compare1,
  typename SuperMeta1,typename TagList1,typename Category1,
  typename KeyFromValue2,typename Compare2,
  typename SuperMeta2,typename TagList2,typename Category2
>
bool operator<=(
  const ordered_index<
    KeyFromValue1,Compare1,SuperMeta1,TagList1,Category1>& x,
  const ordered_index<
    KeyFromValue2,Compare2,SuperMeta2,TagList2,Category2>& y);

template<
  typename KeyFromValue,typename Compare,
  typename SuperMeta,typename TagList,typename Category
>
void swap(
  ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& x,
  ordered_index<KeyFromValue,Compare,SuperMeta,TagList,Category>& y);

}



template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
struct ordered_unique;

template<typename Arg1,typename Arg2=mpl::na,typename Arg3=mpl::na>
struct ordered_non_unique;

}

}
# 20 "/opt/sevenflow/boost/include/boost/multi_index_container_fwd.hpp" 2


namespace boost{

namespace multi_index{





template<
  typename Value,
  typename IndexSpecifierList=indexed_by<ordered_unique<identity<Value> > >,
  typename Allocator=std::allocator<Value> >
class multi_index_container;

template<typename MultiIndexContainer,int N>
struct nth_index;

template<typename MultiIndexContainer,typename Tag>
struct index;

template<typename MultiIndexContainer,int N>
struct nth_index_iterator;

template<typename MultiIndexContainer,int N>
struct nth_index_const_iterator;

template<typename MultiIndexContainer,typename Tag>
struct index_iterator;

template<typename MultiIndexContainer,typename Tag>
struct index_const_iterator;





template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator==(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator<(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator!=(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator>(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator>=(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator<=(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y);

template<typename Value,typename IndexSpecifierList,typename Allocator>
void swap(
  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
  multi_index_container<Value,IndexSpecifierList,Allocator>& y);

}





using multi_index::multi_index_container;

}
# 31 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/access_specifier.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/adl_swap.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/adl_swap.hpp"
namespace boost{

namespace multi_index{

namespace detail{

template<typename T>
void adl_swap(T& x,T& y)
{


  using std::swap;
  swap(x,y);




}

}

}

}
# 33 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/base_type.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/base_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/base_type.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp"
# 1 "/opt/sevenflow/boost/include/boost/call_traits.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/call_traits.hpp"
# 1 "/opt/sevenflow/boost/include/boost/detail/call_traits.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/detail/call_traits.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 25 "/opt/sevenflow/boost/include/boost/detail/call_traits.hpp" 2





namespace boost{

namespace detail{

template <typename T, bool small_>
struct ct_imp2
{
   typedef const T& param_type;
};

template <typename T>
struct ct_imp2<T, true>
{
   typedef const T param_type;
};

template <typename T, bool isp, bool b1>
struct ct_imp
{
   typedef const T& param_type;
};

template <typename T, bool isp>
struct ct_imp<T, isp, true>
{
   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
};

template <typename T, bool b1>
struct ct_imp<T, true, b1>
{
   typedef const T param_type;
};

}

template <typename T>
struct call_traits
{
public:
   typedef T value_type;
   typedef T& reference;
   typedef const T& const_reference;






   typedef typename boost::detail::ct_imp<
      T,
      ::boost::is_pointer<T>::value,
      ::boost::is_arithmetic<T>::value
   >::param_type param_type;
};

template <typename T>
struct call_traits<T&>
{
   typedef T& value_type;
   typedef T& reference;
   typedef const T& const_reference;
   typedef T& param_type;
};
# 135 "/opt/sevenflow/boost/include/boost/detail/call_traits.hpp"
template <typename T, std::size_t N>
struct call_traits<T [N]>
{
private:
   typedef T array_type[N];
public:

   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};

template <typename T, std::size_t N>
struct call_traits<const T [N]>
{
private:
   typedef const T array_type[N];
public:

   typedef const T* value_type;
   typedef array_type& reference;
   typedef const array_type& const_reference;
   typedef const T* const param_type;
};


}
# 22 "/opt/sevenflow/boost/include/boost/call_traits.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/copy_map.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/copy_map.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/auto_space.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/auto_space.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/prevent_eti.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/multi_index/detail/prevent_eti.hpp"
namespace boost{

namespace multi_index{

namespace detail{
# 47 "/opt/sevenflow/boost/include/boost/multi_index/detail/prevent_eti.hpp"
template<typename Type,typename Construct>
struct prevent_eti
{
  typedef Construct type;
};


}

}

}
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/auto_space.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/noncopyable.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/noncopyable.hpp"
namespace boost {






namespace noncopyable_
{
  class noncopyable
  {
   protected:
      noncopyable() {}
      ~noncopyable() {}
   private:
      noncopyable( const noncopyable& );
      const noncopyable& operator=( const noncopyable& );
  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/auto_space.hpp" 2


namespace boost{

namespace multi_index{

namespace detail{
# 46 "/opt/sevenflow/boost/include/boost/multi_index/detail/auto_space.hpp"
template<typename T,typename Allocator=std::allocator<T> >
struct auto_space:private noncopyable
{
  typedef typename prevent_eti<
    Allocator,
    typename boost::detail::allocator::rebind_to<
      Allocator,T
    >::type
  >::type::pointer pointer;

  explicit auto_space(const Allocator& al=Allocator(),std::size_t n=1):
  al_(al),n_(n),data_(n_?al_.allocate(n_):pointer(0))
  {}

  ~auto_space()
  {
    if(n_)al_.deallocate(data_,n_);
  }

  Allocator get_allocator()const{return al_;}

  pointer data()const{return data_;}

  void swap(auto_space& x)
  {
    if(al_!=x.al_)adl_swap(al_,x.al_);
    std::swap(n_,x.n_);
    std::swap(data_,x.data_);
  }

private:
  typename boost::detail::allocator::rebind_to<
    Allocator,T>::type al_;
  std::size_t n_;
  pointer data_;
};

template<typename T,typename Allocator>
void swap(auto_space<T,Allocator>& x,auto_space<T,Allocator>& y)
{
  x.swap(y);
}

}

}

}
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/copy_map.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 23 "/opt/sevenflow/boost/include/boost/multi_index/detail/copy_map.hpp" 2


namespace boost{

namespace multi_index{

namespace detail{
# 43 "/opt/sevenflow/boost/include/boost/multi_index/detail/copy_map.hpp"
template <typename Node>
struct copy_map_entry
{
  copy_map_entry(Node* f,Node* s):first(f),second(s){}

  Node* first;
  Node* second;

  bool operator<(const copy_map_entry<Node>& x)const
  {
    return std::less<Node*>()(first,x.first);
  }
};

template <typename Node,typename Allocator>
class copy_map:private noncopyable
{
public:
  typedef const copy_map_entry<Node>* const_iterator;

  copy_map(
    const Allocator& al,std::size_t size,Node* header_org,Node* header_cpy):
    al_(al),size_(size),spc(al_,size_),n(0),
    header_org_(header_org),header_cpy_(header_cpy),released(false)
  {}

  ~copy_map()
  {
    if(!released){
      for(std::size_t i=0;i<n;++i){
        boost::detail::allocator::destroy(&(spc.data()+i)->second->value());
        deallocate((spc.data()+i)->second);
      }
    }
  }

  const_iterator begin()const{return &*spc.data();}
  const_iterator end()const{return &*(spc.data()+n);}

  void clone(Node* node)
  {
    (spc.data()+n)->first=node;
    (spc.data()+n)->second=&*al_.allocate(1);
    { try{
      boost::detail::allocator::construct(
        &(spc.data()+n)->second->value(),node->value());
    }
    catch(...){
      deallocate((spc.data()+n)->second);
      throw;;
    }
    }
    ++n;

    if(n==size_)std::sort(&*spc.data(),&*spc.data()+size_);
  }

  Node* find(Node* node)const
  {
    if(node==header_org_)return header_cpy_;
    return std::lower_bound(
      begin(),end(),copy_map_entry<Node>(node,0))->second;
  }

  void release()
  {
    released=true;
  }

private:
  typedef typename prevent_eti<
    Allocator,
    typename boost::detail::allocator::rebind_to<
      Allocator,Node>::type
  >::type allocator_type;
  typedef typename allocator_type::pointer allocator_pointer;

  allocator_type al_;
  std::size_t size_;
  auto_space<copy_map_entry<Node>,Allocator> spc;
  std::size_t n;
  Node* header_org_;
  Node* header_cpy_;
  bool released;

  void deallocate(Node* node)
  {
    al_.deallocate(static_cast<allocator_pointer>(node),1);
  }
};

}

}

}
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/bind.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/reverse_iter_fold.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/reverse_iter_fold.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/arg.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/mpl/reverse_iter_fold.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp"
namespace boost { namespace mpl { namespace aux {



template<
      long N
    , typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_iter_fold_impl;

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_iter_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_iter_fold_impl< 1,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;


    typedef fwd_state1 bkwd_state1;
    typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;
    typedef bkwd_state0 state;
    typedef iter1 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_iter_fold_impl< 2,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;


    typedef fwd_state2 bkwd_state2;
    typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
    typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;


    typedef bkwd_state0 state;
    typedef iter2 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_iter_fold_impl< 3,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
    typedef typename mpl::next<iter2>::type iter3;


    typedef fwd_state3 bkwd_state3;
    typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
    typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
    typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::type bkwd_state0;


    typedef bkwd_state0 state;
    typedef iter3 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_iter_fold_impl< 4,First,Last,State,BackwardOp,ForwardOp >
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef fwd_state4 bkwd_state4;
    typedef typename apply2< BackwardOp,bkwd_state4,iter3 >::type bkwd_state3;
    typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
    typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
    typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::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_iter_fold_impl
{
    typedef First iter0;
    typedef State fwd_state0;
    typedef typename apply2< ForwardOp,fwd_state0,iter0 >::type fwd_state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,fwd_state1,iter1 >::type fwd_state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,fwd_state2,iter2 >::type fwd_state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp,fwd_state3,iter3 >::type fwd_state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef reverse_iter_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,iter3 >::type bkwd_state3;
    typedef typename apply2< BackwardOp,bkwd_state3,iter2 >::type bkwd_state2;
    typedef typename apply2< BackwardOp,bkwd_state2,iter1 >::type bkwd_state1;
    typedef typename apply2< BackwardOp,bkwd_state1,iter0 >::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_iter_fold_impl< -1,First,Last,State,BackwardOp,ForwardOp >
{
    typedef reverse_iter_fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2< ForwardOp,State,First >::type
        , BackwardOp
        , ForwardOp
        > nested_step;

    typedef typename apply2<
          BackwardOp
        , typename nested_step::state
        , First
        >::type state;

    typedef typename nested_step::iterator iterator;
};

template<
      typename Last
    , typename State
    , typename BackwardOp
    , typename ForwardOp
    >
struct reverse_iter_fold_impl< -1,Last,Last,State,BackwardOp,ForwardOp >
{
    typedef State state;
    typedef Last iterator;
};

}}}
# 38 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/mpl/aux_/reverse_iter_fold_impl.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/reverse_iter_fold.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename BackwardOp = na
    , typename ForwardOp = arg<1>
    >
struct reverse_iter_fold
{
    typedef typename aux::reverse_iter_fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , typename lambda<BackwardOp>::type
        , typename lambda<ForwardOp>::type
        >::state type;

   




};

template<> struct reverse_iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : reverse_iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< reverse_iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef reverse_iter_fold< na , na , na > result_; typedef reverse_iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< reverse_iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< reverse_iter_fold< na , na , na > > : int_<-1> { }; }

}}
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/header_holder.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/header_holder.hpp"
namespace boost{

namespace multi_index{

namespace detail{
# 32 "/opt/sevenflow/boost/include/boost/multi_index/detail/header_holder.hpp"
template<typename NodeTypePtr,typename Final>
struct header_holder:private noncopyable
{
  header_holder():member(final().allocate_node()){}
  ~header_holder(){final().deallocate_node(&*member);}

  NodeTypePtr member;

private:
  Final& final(){return *static_cast<Final*>(this);}
};

}

}

}
# 23 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_node_base.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_node_base.hpp"
# 1 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp"
# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/archive/detail/decl.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp"
# 1 "/opt/sevenflow/boost/include/boost/archive/detail/abi_prefix.hpp" 1
# 11 "/opt/sevenflow/boost/include/boost/archive/detail/abi_prefix.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/abi_prefix.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/archive/detail/abi_prefix.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp" 2

namespace boost {
namespace archive {




class archive_exception :
    public virtual std::exception
{
public:
    typedef enum {
        no_exception,
        other_exception,
        unregistered_class,

        invalid_signature,

        unsupported_version,

        pointer_conflict,




        incompatible_native_format,

        array_size_too_short,
        input_stream_error,
        invalid_class_name,


        unregistered_cast,

        unsupported_class_version,


        multiple_code_instantiation,

        output_stream_error
    } exception_code;
protected:
    std::string m_msg;
public:
    exception_code code;
    archive_exception(
        exception_code c,
        const char * e1 = __null,
        const char * e2 = __null
    );
    ~archive_exception() throw ();
    virtual const char *what( ) const throw();
protected:
    archive_exception();
};

}
}

# 1 "/opt/sevenflow/boost/include/boost/archive/detail/abi_suffix.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/archive/detail/abi_suffix.hpp"
# 1 "/opt/sevenflow/boost/include/boost/config/abi_suffix.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/archive/detail/abi_suffix.hpp" 2
# 96 "/opt/sevenflow/boost/include/boost/archive/archive_exception.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_node_base.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/access.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/serialization/access.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/pfto.hpp" 1
# 43 "/opt/sevenflow/boost/include/boost/serialization/pfto.hpp"
namespace boost {
namespace serialization {

template<class T>
struct pfto_wrapper {
    const T & t;
    operator const T & (){
        return t;
    }
    pfto_wrapper (const T & rhs) : t(rhs) {}
};

template<class T>
pfto_wrapper< T > make_pfto_wrapper(const T & t, int){
    return pfto_wrapper< T >(t);
}

template<class T>
pfto_wrapper< T > make_pfto_wrapper(const pfto_wrapper< T > & t, int){
    return t;
}

}
}
# 22 "/opt/sevenflow/boost/include/boost/serialization/access.hpp" 2

namespace boost {

namespace archive {
namespace detail {
    template<class Archive, class T>
    class iserializer;
    template<class Archive, class T>
    class oserializer;
}
}

namespace serialization {


template<class Archive, class T>
inline void serialize_adl(Archive &, T &, const unsigned int);
namespace detail {
    template<class Archive, class T>
    struct member_saver;
    template<class Archive, class T>
    struct member_loader;
}






class access {
public:




    template<class Archive, class T>
    friend struct detail::member_saver;
    template<class Archive, class T>
    friend struct detail::member_loader;
    template<class Archive, class T>
    friend class archive::detail::iserializer;
    template<class Archive, class T>
    friend class archive::detail::oserializer;
    template<class Archive, class T>
    friend inline void serialize(
        Archive & ar,
        T & t,
        const unsigned int file_version
    );
    template<class Archive, class T>
    friend inline void save_construct_data(
        Archive & ar,
        const T * t,
        const unsigned int file_version
    );
    template<class Archive, class T>
    friend inline void load_construct_data(
        Archive & ar,
        T * t,
        const unsigned int file_version
    );



    template<class Archive, class T>
    static void member_save(
        Archive & ar,

        T & t,
        const unsigned int file_version
    ){
        t.save(ar, file_version);
    }
    template<class Archive, class T>
    static void member_load(
        Archive & ar,
        T & t,
        const unsigned int file_version
    ){
        t.load(ar, file_version);
    }
    template<class Archive, class T>
    static void serialize(
        Archive & ar,
        T & t,
        const unsigned int file_version
    ){
# 118 "/opt/sevenflow/boost/include/boost/serialization/access.hpp"
        t.serialize(ar, file_version);
    }
    template<class T>
    static void destroy( const T * t)
    {


        delete const_cast<T *>(t);
    }
    template<class T>
    static void construct(T * t){



        ::new(t)T;
    }
    template<class T, class U>
    static T & cast_reference(U & u){
        return static_cast<T &>(u);
    }
    template<class T, class U>
    static T * cast_pointer(U * u){
        return static_cast<T *>(u);
    }
};

}
}
# 23 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_node_base.hpp" 2



namespace boost{

namespace multi_index{

namespace detail{





template<typename Value>
struct pod_value_holder
{
  typename aligned_storage<
    sizeof(Value),
    alignment_of<Value>::value
  >::type space;
};

template<typename Value,typename Allocator>
struct index_node_base:private pod_value_holder<Value>
{
  typedef index_node_base base_type;
  typedef Value value_type;
  typedef Allocator allocator_type;

  value_type& value()
  {
    return *static_cast<value_type*>(
      static_cast<void*>(&this->space));
  }

  const value_type& value()const
  {
    return *static_cast<const value_type*>(
      static_cast<const void*>(&this->space));
  }

  static index_node_base* from_value(const value_type* p)
  {
    return static_cast<index_node_base *>(
      reinterpret_cast<pod_value_holder<Value>*>(
        const_cast<value_type*>(p)));
  }

private:

  friend class boost::serialization::access;






  template<class Archive>
  void serialize(Archive&,const unsigned int)
  {
  }

};

template<typename Node,typename Value>
Node* node_from_value(
  const Value* p
  )
{
  typedef typename Node::allocator_type allocator_type;
  return static_cast<Node*>(
    index_node_base<Value,allocator_type>::from_value(p));
}

}

}
# 111 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_node_base.hpp"
namespace multi_index{
namespace detail{


template<class Archive,typename Value,typename Allocator>
inline void load_construct_data(
  Archive&,boost::multi_index::detail::index_node_base<Value,Allocator>*,
  const unsigned int)
{
  throw_exception(
    archive::archive_exception(archive::archive_exception::other_exception));
}




}
}




}
# 24 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/is_index_list.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/detail/is_index_list.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/empty.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/empty.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/empty_impl.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/empty_impl.hpp"
namespace boost { namespace mpl {




template< typename Tag >
struct empty_impl
{
    template< typename Sequence > struct apply
        : is_same<
              typename begin<Sequence>::type
            , typename end<Sequence>::type
            >
    {
    };
};

 template<> struct empty_impl<non_sequence_tag> {};

}}
# 20 "/opt/sevenflow/boost/include/boost/mpl/empty.hpp" 2



namespace boost { namespace mpl {

template<
      typename Sequence = na
    >
struct empty
    : empty_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{
   
};

template<> struct empty< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : empty< T1 > { }; }; template< typename Tag > struct lambda< empty< na > , Tag , int_<-1> > { typedef false_ is_le; typedef empty< na > result_; typedef empty< na > type; }; namespace aux { template< typename T1 > struct template_arity< empty< T1 > > : int_<1> { }; template<> struct template_arity< empty< na > > : int_<-1> { }; }

}}
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/is_index_list.hpp" 2


namespace boost{

namespace multi_index{

namespace detail{

template<typename T>
struct is_index_list
{
  static const bool mpl_sequence=mpl::is_sequence<T>::value;
  static const bool non_empty=!mpl::empty<T>::value;
  static const bool value=mpl_sequence&&non_empty;
};

}

}

}
# 25 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/msvc_index_specifier.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp" 2


namespace boost{

namespace multi_index{

namespace detail{
# 49 "/opt/sevenflow/boost/include/boost/multi_index/detail/node_type.hpp"
struct index_node_applier
{
  template<typename IndexSpecifierIterator,typename Super>
  struct apply
  {
    typedef typename mpl::deref<IndexSpecifierIterator>::type index_specifier;
    typedef typename index_specifier::
      template node_class<Super>::type type;
  };
};


template<typename Value,typename IndexSpecifierList,typename Allocator>
struct multi_index_node_type
{
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((detail::is_index_list<IndexSpecifierList>::value) == 0 ? false : true) >)> boost_static_assert_typedef_64;

  typedef typename mpl::reverse_iter_fold<
    IndexSpecifierList,
    index_node_base<Value,Allocator>,
    mpl::bind2<index_node_applier,mpl::_2,mpl::_1>
  >::type type;
};

}

}

}
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/tuple/tuple.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/tuple/tuple.hpp"
# 1 "/opt/sevenflow/boost/include/boost/ref.hpp" 1
# 29 "/opt/sevenflow/boost/include/boost/ref.hpp"
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 "/opt/sevenflow/boost/include/boost/ref.hpp"
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 "/opt/sevenflow/boost/include/boost/ref.hpp"
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 "/opt/sevenflow/boost/include/boost/tuple/tuple.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp"
# 1 "/opt/sevenflow/boost/include/boost/type_traits/cv_traits.hpp" 1
# 39 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/utility/swap.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/utility/swap.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 26 "/opt/sevenflow/boost/include/boost/utility/swap.hpp" 2

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);
  }
}
# 41 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp" 2



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 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp"
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 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp"
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 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp"
template<class T>
struct make_tuple_traits {
  typedef T type;







};
# 660 "/opt/sevenflow/boost/include/boost/tuple/detail/tuple_basic.hpp"
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 "/opt/sevenflow/boost/include/boost/tuple/tuple.hpp" 2



namespace boost {

using tuples::tuple;
using tuples::make_tuple;
using tuples::tie;

using tuples::get;
# 87 "/opt/sevenflow/boost/include/boost/tuple/tuple.hpp"
}
# 24 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_loader.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_loader.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/level.hpp" 1
# 34 "/opt/sevenflow/boost/include/boost/serialization/level.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/level_enum.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/serialization/level_enum.hpp"
namespace boost {
namespace serialization {





enum level_type
{


    not_serializable = 0,






    primitive_type = 1,



    object_serializable = 2,







    object_class_info = 3
};

}
}
# 35 "/opt/sevenflow/boost/include/boost/serialization/level.hpp" 2

namespace boost {
namespace serialization {

struct basic_traits;


template<class T>
struct implementation_level_impl {
    template<class U>
    struct traits_class_level {
        typedef typename U::level type;
    };

    typedef mpl::integral_c_tag tag;


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits, T>,
            traits_class_level< T >,

        typename mpl::eval_if<
            is_fundamental< T >,
            mpl::int_<primitive_type>,

        typename mpl::eval_if<
            is_class< T >,
            mpl::int_<object_class_info>,

        typename mpl::eval_if<
            is_array< T >,



                mpl::int_<object_serializable>,


        typename mpl::eval_if<
            is_enum< T >,



                mpl::int_<primitive_type>,


            mpl::int_<not_serializable>
        >
        >
        >
        >
        >::type type;

    static const int value = type::value;
};

template<class T>
struct implementation_level :
    public implementation_level_impl<const T>
{
};

template<class T, int L >
inline bool operator>=(implementation_level< T > t, enum level_type l)
{
    return t.value >= (int)l;
}

}
}
# 32 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/tracking.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/serialization/tracking.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/equal_to.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/equal_to.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/equal_to.hpp" 2
# 25 "/opt/sevenflow/boost/include/boost/serialization/tracking.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/greater.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/greater.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/greater.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/greater.hpp" 2
# 26 "/opt/sevenflow/boost/include/boost/serialization/tracking.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/serialization/tracking_enum.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/serialization/tracking_enum.hpp"
namespace boost {
namespace serialization {






enum tracking_type
{

    track_never = 0,


    track_selectively = 1,

    track_always = 2
};

}
}
# 32 "/opt/sevenflow/boost/include/boost/serialization/tracking.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/type_info_implementation.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/serialization/type_info_implementation.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/traits.hpp" 1
# 35 "/opt/sevenflow/boost/include/boost/serialization/traits.hpp"
namespace boost {
namespace serialization {


struct basic_traits {};

template <class T>
struct extended_type_info_impl;

template<
    class T,
    int Level,
    int Tracking,
    unsigned int Version = 0,
    class ETII = extended_type_info_impl< T >,
    class Wrapper = mpl::false_
>
struct traits : public basic_traits {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Version == 0 || Level >= object_class_info) == 0 ? false : true) >)> boost_static_assert_typedef_53;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((Tracking == track_never || Level >= object_serializable) == 0 ? false : true) >)> boost_static_assert_typedef_54;
    typedef typename mpl::int_<Level> level;
    typedef typename mpl::int_<Tracking> tracking;
    typedef typename mpl::int_<Version> version;
    typedef ETII type_info_implementation;
    typedef Wrapper is_wrapper;
};

}
}
# 28 "/opt/sevenflow/boost/include/boost/serialization/type_info_implementation.hpp" 2

namespace boost {
namespace serialization {



template<class T>
struct type_info_implementation {
    template<class U>
    struct traits_class_typeinfo_implementation {
      typedef typename U::type_info_implementation::type type;
    };


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits, T>,
            traits_class_typeinfo_implementation< T >,

            mpl::identity<
                typename extended_type_info_impl< T >::type
            >
        >::type type;
};

}
}
# 33 "/opt/sevenflow/boost/include/boost/serialization/tracking.hpp" 2

namespace boost {
namespace serialization {

struct basic_traits;


template<class T>
struct tracking_level_impl {
    template<class U>
    struct traits_class_tracking {
        typedef typename U::tracking type;
    };
    typedef mpl::integral_c_tag tag;


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits, T>,
            traits_class_tracking< T >,

        typename mpl::eval_if<
            is_pointer< T >,

            mpl::int_<track_never>,

        typename mpl::eval_if<

            typename mpl::equal_to<
                implementation_level< T >,
                mpl::int_<primitive_type>
            >,

            mpl::int_<track_never>,

            mpl::int_<track_selectively>
    > > >::type type;
    static const int value = type::value;
};

template<class T>
struct tracking_level :
    public tracking_level_impl<const T>
{
};

template<class T, enum tracking_type L>
inline bool operator>=(tracking_level< T > t, enum tracking_type l)
{
    return t.value >= (int)l;
}

}
}
# 33 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/split_member.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/serialization/split_member.hpp"
namespace boost {
namespace archive {
    namespace detail {
        template<class Archive> class interface_oarchive;
        template<class Archive> class interface_iarchive;
    }
}

namespace serialization {
namespace detail {

    template<class Archive, class T>
    struct member_saver {
        static void invoke(
            Archive & ar,
            const T & t,
            const unsigned int file_version
        ){
            access::member_save(ar, t, file_version);
        }
    };

    template<class Archive, class T>
    struct member_loader {
        static void invoke(
            Archive & ar,
            T & t,
            const unsigned int file_version
        ){
            access::member_load(ar, t, file_version);
        }
    };

}

template<class Archive, class T>
inline void split_member(
    Archive & ar, T & t, const unsigned int file_version
){
    typedef typename mpl::eval_if<
        typename Archive::is_saving,
        mpl::identity<detail::member_saver<Archive, T> >,
        mpl::identity<detail::member_loader<Archive, T> >
    >::type typex;
    typex::invoke(ar, t, file_version);
}

}
}
# 34 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/base_object.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/serialization/base_object.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/force_include.hpp" 1
# 39 "/opt/sevenflow/boost/include/boost/serialization/base_object.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/void_cast_fwd.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/serialization/void_cast_fwd.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/serialization/void_cast_fwd.hpp" 2


namespace boost {
namespace serialization {
namespace void_cast_detail{
class void_caster;
}
template<class Derived, class Base>

inline const void_cast_detail::void_caster & void_cast_register(
    const Derived * dnull = __null,
    const Base * bnull = __null
) __attribute__ ((__used__));
}
}
# 40 "/opt/sevenflow/boost/include/boost/serialization/base_object.hpp" 2

namespace boost {
namespace serialization {

namespace detail
{


    template<class B, class D>
    struct base_cast
    {
        typedef typename
        mpl::if_<
            is_const<D>,
            const B,
            B
        >::type type;
        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_const<type>::value == is_const<D>::value) == 0 ? false : true) >)> boost_static_assert_typedef_57;
    };


    template<class Base, class Derived>
    struct base_register
    {
        struct polymorphic {
            static void const * invoke(){
                Base const * const b = 0;
                Derived const * const d = 0;
                return & void_cast_register(d, b);
            }
        };
        struct non_polymorphic {
            static void const * invoke(){
                return 0;
            }
        };
        static void const * invoke(){
            typedef typename mpl::eval_if<
                is_polymorphic<Base>,
                mpl::identity<polymorphic>,
                mpl::identity<non_polymorphic>
            >::type type;
            return type::invoke();
        }
    };

}
# 97 "/opt/sevenflow/boost/include/boost/serialization/base_object.hpp"
template<class Base, class Derived>
typename detail::base_cast<Base, Derived>::type &
base_object(Derived &d)
{
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_base_and_derived<Base,Derived>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_101;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((! is_pointer<Derived>::value) == 0 ? false : true) >)> boost_static_assert_typedef_102;
    typedef typename detail::base_cast<Base, Derived>::type type;
    detail::base_register<type, Derived>::invoke();
    return access::cast_reference<type, Derived>(d);
}


}
}
# 35 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/serialization/wrapper.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/serialization/wrapper.hpp"
namespace boost { namespace serialization {







template<
    class T,
    int Level = object_serializable,
    int Tracking = track_never,
    unsigned int Version = 0,
    class ETII = extended_type_info_impl< T >
>
struct wrapper_traits :
    public traits<T,Level,Tracking,Version,ETII,mpl::true_>
{};

template<class T>
struct is_wrapper_impl :
    boost::mpl::eval_if<
      boost::is_base_and_derived<basic_traits,T>,
      boost::mpl::true_,
      boost::mpl::false_
    >::type
{};

template<class T>
struct is_wrapper {
    typedef typename is_wrapper_impl<const T>::type type;
};

}
}
# 37 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp" 2

namespace boost {
namespace serialization {

template<class T>
struct nvp :
    public std::pair<const char *, T *>,
    public wrapper_traits<const nvp< T > >
{
    explicit nvp(const char * name_, T & t) :


        std::pair<const char *, T *>(name_, (T*)(& t))
    {}
    nvp(const nvp & rhs) :

        std::pair<const char *, T *>(rhs.first, (T*)rhs.second)
    {}

    const char * name() const {
        return this->first;
    }
    T & value() const {
        return *(this->second);
    }

    const T & const_value() const {
        return *(this->second);
    }







    template<class Archivex>
    void save(
        Archivex & ar,
        const unsigned int
    ) const {

        ar.operator<<(const_value());
    }
    template<class Archivex>
    void load(
        Archivex & ar,
        const unsigned int
    ){

        ar.operator>>(value());
    }
    template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }
};

template<class T>
inline

const

nvp< T > make_nvp(const char * name, T & t){
    return nvp< T >(name, t);
}
# 128 "/opt/sevenflow/boost/include/boost/serialization/nvp.hpp"
}
}
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_loader.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 24 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_loader.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{







template<typename Node,typename FinalNode,typename Allocator>
class index_loader:private noncopyable
{
public:
  index_loader(const Allocator& al,std::size_t size):
    spc(al,size),size_(size),n(0),sorted(false)
  {
  }

  template<class Archive>
  void add(Node* node,Archive& ar,const unsigned int)
  {
    ar>>serialization::make_nvp("position",*node);
    entries()[n++]=node;
  }

  template<class Archive>
  void add_track(Node* node,Archive& ar,const unsigned int)
  {
    ar>>serialization::make_nvp("position",*node);
  }







  template<typename Rearranger,class Archive>
  void load(Rearranger r,Archive& ar,const unsigned int)const
  {
    FinalNode* prev=unchecked_load_node(ar);
    if(!prev)return;

    if(!sorted){
      std::sort(entries(),entries()+size_);
      sorted=true;
    }

    check_node(prev);

    for(;;){
      for(;;){
        FinalNode* node=load_node(ar);
        if(!node)break;

        if(node==prev)prev=0;
        r(prev,node);

        prev=node;
      }
      prev=load_node(ar);
      if(!prev)break;
    }
  }

private:
  Node** entries()const{return &*spc.data();}





  template<class Archive>
  FinalNode* unchecked_load_node(Archive& ar)const
  {
    Node* node=0;
    ar>>serialization::make_nvp("pointer",node);
    return static_cast<FinalNode*>(node);
  }

  template<class Archive>
  FinalNode* load_node(Archive& ar)const
  {
    Node* node=0;
    ar>>serialization::make_nvp("pointer",node);
    check_node(node);
    return static_cast<FinalNode*>(node);
  }

  void check_node(Node* node)const
  {
    if(node!=0&&!std::binary_search(entries(),entries()+size_,node)){
      throw_exception(
        archive::archive_exception(
          archive::archive_exception::other_exception));
    }
  }

  auto_space<Node*,Allocator> spc;
  std::size_t size_;
  std::size_t n;
  mutable bool sorted;
};

}

}

}
# 28 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_saver.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_saver.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_matcher.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_matcher.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_matcher.hpp" 2


namespace boost{

namespace multi_index{

namespace detail{
# 58 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_matcher.hpp"
namespace index_matcher{
# 67 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_matcher.hpp"
struct entry
{
  entry(void* node_,std::size_t pos_=0):node(node_),pos(pos_){}



  void* node;
  std::size_t pos;
  entry* previous;
  bool ordered;

  struct less_by_node
  {
    bool operator()(
      const entry& x,const entry& y)const
    {
      return std::less<void*>()(x.node,y.node);
    }
  };



  std::size_t pile_top;
  entry* pile_top_entry;

  struct less_by_pile_top
  {
    bool operator()(
      const entry& x,const entry& y)const
    {
      return x.pile_top<y.pile_top;
    }
  };
};



template<typename Allocator>
class algorithm_base:private noncopyable
{
protected:
  algorithm_base(const Allocator& al,std::size_t size):
    spc(al,size),size_(size),n(0),sorted(false)
  {
  }

  void add(void* node)
  {
    entries()[n]=entry(node,n);
    ++n;
  }

  void begin_algorithm()const
  {
    if(!sorted){
      std::sort(entries(),entries()+size_,entry::less_by_node());
      sorted=true;
    }
    num_piles=0;
  }

  void add_node_to_algorithm(void* node)const
  {
    entry* ent=
      std::lower_bound(
        entries(),entries()+size_,
        entry(node),entry::less_by_node());
    ent->ordered=false;
    std::size_t n=ent->pos;

    entry dummy(0);
    dummy.pile_top=n;

    entry* pile_ent=
      std::lower_bound(
        entries(),entries()+num_piles,
        dummy,entry::less_by_pile_top());

    pile_ent->pile_top=n;
    pile_ent->pile_top_entry=ent;


    if(pile_ent>&entries()[0]){
      ent->previous=(pile_ent-1)->pile_top_entry;
    }

    if(pile_ent==&entries()[num_piles]){
      ++num_piles;
    }
  }

  void finish_algorithm()const
  {
    if(num_piles>0){





      entry* ent=entries()[num_piles-1].pile_top_entry;
      for(std::size_t n=num_piles;n--;){
        ent->ordered=true;
        ent=ent->previous;
      }
    }
  }

  bool is_ordered(void * node)const
  {
    return std::lower_bound(
      entries(),entries()+size_,
      entry(node),entry::less_by_node())->ordered;
  }

private:
  entry* entries()const{return &*spc.data();}

  auto_space<entry,Allocator> spc;
  std::size_t size_;
  std::size_t n;
  mutable bool sorted;
  mutable std::size_t num_piles;
};







template<typename Node,typename Allocator>
class algorithm:private algorithm_base<Allocator>
{
  typedef algorithm_base<Allocator> super;

public:
  algorithm(const Allocator& al,std::size_t size):super(al,size){}

  void add(Node* node)
  {
    super::add(node);
  }

  template<typename IndexIterator>
  void execute(IndexIterator first,IndexIterator last)const
  {
    super::begin_algorithm();

    for(IndexIterator it=first;it!=last;++it){
      add_node_to_algorithm(get_node(it));
    }

    super::finish_algorithm();
  }

  bool is_ordered(Node* node)const
  {
    return super::is_ordered(node);
  }

private:
  void add_node_to_algorithm(Node* node)const
  {
    super::add_node_to_algorithm(node);
  }

  template<typename IndexIterator>
  static Node* get_node(IndexIterator it)
  {
    return static_cast<Node*>(it.get_node());
  }
};

}

}

}

}
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_saver.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_saver.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{
# 37 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_saver.hpp"
template<typename Node,typename Allocator>
class index_saver:private noncopyable
{
public:
  index_saver(const Allocator& al,std::size_t size):alg(al,size){}

  template<class Archive>
  void add(Node* node,Archive& ar,const unsigned int)
  {
    ar<<serialization::make_nvp("position",*node);
    alg.add(node);
  }

  template<class Archive>
  void add_track(Node* node,Archive& ar,const unsigned int)
  {
    ar<<serialization::make_nvp("position",*node);
  }

  template<typename IndexIterator,class Archive>
  void save(
    IndexIterator first,IndexIterator last,Archive& ar,
    const unsigned int)const
  {


    alg.execute(first,last);
# 95 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_saver.hpp"
    std::size_t last_saved=3;
    for(IndexIterator it=first,prev=first;it!=last;prev=it++,++last_saved){
      if(!alg.is_ordered(get_node(it))){
        if(last_saved>1)save_node(get_node(prev),ar);
        save_node(get_node(it),ar);
        last_saved=0;
      }
      else if(last_saved==2)save_node(null_node(),ar);
    }
    if(last_saved<=2)save_node(null_node(),ar);



    save_node(null_node(),ar);
  }

private:
  template<typename IndexIterator>
  static Node* get_node(IndexIterator it)
  {
    return it.get_node();
  }

  static Node* null_node(){return 0;}

  template<typename Archive>
  static void save_node(Node* node,Archive& ar)
  {
    ar<<serialization::make_nvp("pointer",node);
  }

  index_matcher::algorithm<Node,Allocator> alg;
};

}

}

}
# 29 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp" 2


namespace boost{

namespace multi_index{

namespace detail{
# 45 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp"
template<typename Value,typename IndexSpecifierList,typename Allocator>
class index_base
{
protected:
  typedef index_node_base<Value,Allocator> node_type;
  typedef typename multi_index_node_type<
    Value,IndexSpecifierList,Allocator>::type final_node_type;
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> final_type;
  typedef tuples::null_type ctor_args_list;
  typedef typename
    boost::detail::allocator::rebind_to<
      Allocator,
      typename Allocator::value_type>::type final_allocator_type;
  typedef mpl::vector0<> index_type_list;
  typedef mpl::vector0<> iterator_type_list;
  typedef mpl::vector0<> const_iterator_type_list;
  typedef copy_map<
    final_node_type,
    final_allocator_type> copy_map_type;


  typedef index_saver<
    node_type,
    final_allocator_type> index_saver_type;
  typedef index_loader<
    node_type,
    final_node_type,
    final_allocator_type> index_loader_type;


private:
  typedef typename call_traits<Value>::param_type value_param_type;

protected:
  explicit index_base(const ctor_args_list&,const Allocator&){}

  void copy_(
    const index_base<Value,IndexSpecifierList,Allocator>&,const copy_map_type&)
  {}

  node_type* insert_(value_param_type v,node_type* x)
  {
    boost::detail::allocator::construct(&x->value(),v);
    return x;
  }

  node_type* insert_(value_param_type v,node_type*,node_type* x)
  {
    boost::detail::allocator::construct(&x->value(),v);
    return x;
  }

  void erase_(node_type* x)
  {
    boost::detail::allocator::destroy(&x->value());
  }

  void delete_node_(node_type* x)
  {
    boost::detail::allocator::destroy(&x->value());
  }

  void clear_(){}

  void swap_(index_base<Value,IndexSpecifierList,Allocator>&){}

  bool replace_(value_param_type v,node_type* x)
  {
    x->value()=v;
    return true;
  }

  bool modify_(node_type*){return true;}

  bool modify_rollback_(node_type*){return true;}




  template<typename Archive>
  void save_(Archive&,const unsigned int,const index_saver_type&)const{}

  template<typename Archive>
  void load_(Archive&,const unsigned int,const index_loader_type&){}
# 140 "/opt/sevenflow/boost/include/boost/multi_index/detail/index_base.hpp"
  final_type& final(){return *static_cast<final_type*>(this);}
  const final_type& final()const{return *static_cast<const final_type*>(this);}

  final_node_type* final_header()const{return final().header();}

  bool final_empty_()const{return final().empty_();}
  std::size_t final_size_()const{return final().size_();}
  std::size_t final_max_size_()const{return final().max_size_();}

  std::pair<final_node_type*,bool> final_insert_(value_param_type x)
    {return final().insert_(x);}
  std::pair<final_node_type*,bool> final_insert_(
    value_param_type x,final_node_type* position)
    {return final().insert_(x,position);}

  void final_erase_(final_node_type* x){final().erase_(x);}

  void final_delete_node_(final_node_type* x){final().delete_node_(x);}
  void final_delete_all_nodes_(){final().delete_all_nodes_();}
  void final_clear_(){final().clear_();}

  void final_swap_(final_type& x){final().swap_(x);}
  bool final_replace_(
    value_param_type k,final_node_type* x)
    {return final().replace_(k,x);}

  template<typename Modifier>
  bool final_modify_(Modifier& mod,final_node_type* x)
    {return final().modify_(mod,x);}

  template<typename Modifier,typename Rollback>
  bool final_modify_(Modifier& mod,Rollback& back,final_node_type* x)
    {return final().modify_(mod,back,x);}




};

}

}

}
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/base_type.hpp" 2




namespace boost{

namespace multi_index{

namespace detail{
# 47 "/opt/sevenflow/boost/include/boost/multi_index/detail/base_type.hpp"
struct index_applier
{
  template<typename IndexSpecifierMeta,typename SuperMeta>
  struct apply
  {
    typedef typename IndexSpecifierMeta::type index_specifier;
    typedef typename index_specifier::
      template index_class<SuperMeta>::type type;
  };
};


template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
struct nth_layer
{
  static const int length=mpl::size<IndexSpecifierList>::value;

  typedef typename mpl::eval_if_c<
    N==length,
    mpl::identity<index_base<Value,IndexSpecifierList,Allocator> >,
    mpl::apply2<
      index_applier,
      mpl::at_c<IndexSpecifierList,N>,
      nth_layer<N+1,Value,IndexSpecifierList,Allocator>
    >
  >::type type;
};

template<typename Value,typename IndexSpecifierList,typename Allocator>
struct multi_index_base_type:nth_layer<0,Value,IndexSpecifierList,Allocator>
{
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((detail::is_index_list<IndexSpecifierList>::value) == 0 ? false : true) >)> boost_static_assert_typedef_78;
};

}

}

}
# 34 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/converter.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/multi_index/detail/converter.hpp"
namespace boost{

namespace multi_index{

namespace detail{






template<typename MultiIndexContainer,typename Index>
struct converter
{
  static const Index& index(const MultiIndexContainer& x){return x;}
  static Index& index(MultiIndexContainer& x){return x;}

  static typename Index::const_iterator const_iterator(
    const MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
  {
    return x.Index::make_iterator(node);
  }

  static typename Index::iterator iterator(
    MultiIndexContainer& x,typename MultiIndexContainer::node_type* node)
  {
    return x.Index::make_iterator(node);
  }
};

}

}

}
# 35 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/has_tag.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/has_tag.hpp"
namespace boost{

namespace multi_index{

namespace detail{



template<typename Tag>
struct has_tag
{
  template<typename Index>
  struct apply:mpl::contains<typename Index::tag_list,Tag>
  {
  };
};

}

}

}
# 37 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/safe_mode.hpp" 1
# 40 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/scope_guard.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/scope_guard.hpp"
namespace boost{

namespace multi_index{

namespace detail{
# 59 "/opt/sevenflow/boost/include/boost/multi_index/detail/scope_guard.hpp"
class scope_guard_impl_base
{
public:
  scope_guard_impl_base():dismissed_(false){}
  void dismiss()const{dismissed_=true;}




  void touch()const{}

protected:
  ~scope_guard_impl_base(){}

  scope_guard_impl_base(const scope_guard_impl_base& other):
    dismissed_(other.dismissed_)
  {
    other.dismiss();
  }

  template<typename J>
  static void safe_execute(J& j){
    { try{
      if(!j.dismissed_)j.execute();
    }
    catch(...){}
    }
  }

  mutable bool dismissed_;

private:
  scope_guard_impl_base& operator=(const scope_guard_impl_base&);
};

typedef const scope_guard_impl_base& scope_guard;

struct null_guard : public scope_guard_impl_base
{
    template< class T1 >
    null_guard( const T1& )
    { }

    template< class T1, class T2 >
    null_guard( const T1&, const T2& )
    { }

    template< class T1, class T2, class T3 >
    null_guard( const T1&, const T2&, const T3& )
    { }

    template< class T1, class T2, class T3, class T4 >
    null_guard( const T1&, const T2&, const T3&, const T4& )
    { }

    template< class T1, class T2, class T3, class T4, class T5 >
    null_guard( const T1&, const T2&, const T3&, const T4&, const T5& )
    { }
};

template< bool cond, class T >
struct null_guard_return
{
    typedef typename boost::mpl::if_c<cond,T,null_guard>::type type;
};

template<typename F>
class scope_guard_impl0:public scope_guard_impl_base
{
public:
  scope_guard_impl0(F fun):fun_(fun){}
  ~scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){fun_();}

protected:

  F fun_;
};

template<typename F>
inline scope_guard_impl0<F> make_guard(F fun)
{
  return scope_guard_impl0<F>(fun);
}

template<bool cond, typename F>
inline typename null_guard_return<cond,scope_guard_impl0<F> >::type
make_guard_if_c(F fun)
{
  return typename null_guard_return<cond,scope_guard_impl0<F> >::type(fun);
}

template<typename C, typename F>
inline typename null_guard_return<C::value,scope_guard_impl0<F> >::type
make_guard_if(F fun)
{
  return make_guard_if<C::value>(fun);
}

template<typename F,typename P1>
class scope_guard_impl1:public scope_guard_impl_base
{
public:
  scope_guard_impl1(F fun,P1 p1):fun_(fun),p1_(p1){}
  ~scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){fun_(p1_);}

protected:
  F fun_;
  const P1 p1_;
};

template<typename F,typename P1>
inline scope_guard_impl1<F,P1> make_guard(F fun,P1 p1)
{
  return scope_guard_impl1<F,P1>(fun,p1);
}

template<bool cond, typename F,typename P1>
inline typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type
make_guard_if_c(F fun,P1 p1)
{
  return typename null_guard_return<cond,scope_guard_impl1<F,P1> >::type(fun,p1);
}

template<typename C, typename F,typename P1>
inline typename null_guard_return<C::value,scope_guard_impl1<F,P1> >::type
make_guard_if(F fun,P1 p1)
{
  return make_guard_if_c<C::value>(fun,p1);
}

template<typename F,typename P1,typename P2>
class scope_guard_impl2:public scope_guard_impl_base
{
public:
  scope_guard_impl2(F fun,P1 p1,P2 p2):fun_(fun),p1_(p1),p2_(p2){}
  ~scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){fun_(p1_,p2_);}

protected:
  F fun_;
  const P1 p1_;
  const P2 p2_;
};

template<typename F,typename P1,typename P2>
inline scope_guard_impl2<F,P1,P2> make_guard(F fun,P1 p1,P2 p2)
{
  return scope_guard_impl2<F,P1,P2>(fun,p1,p2);
}

template<bool cond, typename F,typename P1,typename P2>
inline typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type
make_guard_if_c(F fun,P1 p1,P2 p2)
{
  return typename null_guard_return<cond,scope_guard_impl2<F,P1,P2> >::type(fun,p1,p2);
}

template<typename C, typename F,typename P1,typename P2>
inline typename null_guard_return<C::value,scope_guard_impl2<F,P1,P2> >::type
make_guard_if(F fun,P1 p1,P2 p2)
{
  return make_guard_if_c<C::value>(fun,p1,p2);
}

template<typename F,typename P1,typename P2,typename P3>
class scope_guard_impl3:public scope_guard_impl_base
{
public:
  scope_guard_impl3(F fun,P1 p1,P2 p2,P3 p3):fun_(fun),p1_(p1),p2_(p2),p3_(p3){}
  ~scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){fun_(p1_,p2_,p3_);}

protected:
  F fun_;
  const P1 p1_;
  const P2 p2_;
  const P3 p3_;
};

template<typename F,typename P1,typename P2,typename P3>
inline scope_guard_impl3<F,P1,P2,P3> make_guard(F fun,P1 p1,P2 p2,P3 p3)
{
  return scope_guard_impl3<F,P1,P2,P3>(fun,p1,p2,p3);
}

template<bool cond,typename F,typename P1,typename P2,typename P3>
inline typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type
make_guard_if_c(F fun,P1 p1,P2 p2,P3 p3)
{
  return typename null_guard_return<cond,scope_guard_impl3<F,P1,P2,P3> >::type(fun,p1,p2,p3);
}

template<typename C,typename F,typename P1,typename P2,typename P3>
inline typename null_guard_return< C::value,scope_guard_impl3<F,P1,P2,P3> >::type
make_guard_if(F fun,P1 p1,P2 p2,P3 p3)
{
  return make_guard_if_c<C::value>(fun,p1,p2,p3);
}

template<typename F,typename P1,typename P2,typename P3,typename P4>
class scope_guard_impl4:public scope_guard_impl_base
{
public:
  scope_guard_impl4(F fun,P1 p1,P2 p2,P3 p3,P4 p4):
    fun_(fun),p1_(p1),p2_(p2),p3_(p3),p4_(p4){}
  ~scope_guard_impl4(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){fun_(p1_,p2_,p3_,p4_);}

protected:
  F fun_;
  const P1 p1_;
  const P2 p2_;
  const P3 p3_;
  const P4 p4_;
};

template<typename F,typename P1,typename P2,typename P3,typename P4>
inline scope_guard_impl4<F,P1,P2,P3,P4> make_guard(
  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
{
  return scope_guard_impl4<F,P1,P2,P3,P4>(fun,p1,p2,p3,p4);
}

template<bool cond, typename F,typename P1,typename P2,typename P3,typename P4>
inline typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type
make_guard_if_c(
  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
{
  return typename null_guard_return<cond,scope_guard_impl4<F,P1,P2,P3,P4> >::type(fun,p1,p2,p3,p4);
}

template<typename C, typename F,typename P1,typename P2,typename P3,typename P4>
inline typename null_guard_return<C::value,scope_guard_impl4<F,P1,P2,P3,P4> >::type
make_guard_if(
  F fun,P1 p1,P2 p2,P3 p3,P4 p4)
{
  return make_guard_if_c<C::value>(fun,p1,p2,p3,p4);
}

template<class Obj,typename MemFun>
class obj_scope_guard_impl0:public scope_guard_impl_base
{
public:
  obj_scope_guard_impl0(Obj& obj,MemFun mem_fun):obj_(obj),mem_fun_(mem_fun){}
  ~obj_scope_guard_impl0(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){(obj_.*mem_fun_)();}

protected:
  Obj& obj_;
  MemFun mem_fun_;
};

template<class Obj,typename MemFun>
inline obj_scope_guard_impl0<Obj,MemFun> make_obj_guard(Obj& obj,MemFun mem_fun)
{
  return obj_scope_guard_impl0<Obj,MemFun>(obj,mem_fun);
}

template<bool cond, class Obj,typename MemFun>
inline typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type
make_obj_guard_if_c(Obj& obj,MemFun mem_fun)
{
  return typename null_guard_return<cond,obj_scope_guard_impl0<Obj,MemFun> >::type(obj,mem_fun);
}

template<typename C, class Obj,typename MemFun>
inline typename null_guard_return<C::value,obj_scope_guard_impl0<Obj,MemFun> >::type
make_obj_guard_if(Obj& obj,MemFun mem_fun)
{
  return make_obj_guard_if_c<C::value>(obj,mem_fun);
}

template<class Obj,typename MemFun,typename P1>
class obj_scope_guard_impl1:public scope_guard_impl_base
{
public:
  obj_scope_guard_impl1(Obj& obj,MemFun mem_fun,P1 p1):
    obj_(obj),mem_fun_(mem_fun),p1_(p1){}
  ~obj_scope_guard_impl1(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){(obj_.*mem_fun_)(p1_);}

protected:
  Obj& obj_;
  MemFun mem_fun_;
  const P1 p1_;
};

template<class Obj,typename MemFun,typename P1>
inline obj_scope_guard_impl1<Obj,MemFun,P1> make_obj_guard(
  Obj& obj,MemFun mem_fun,P1 p1)
{
  return obj_scope_guard_impl1<Obj,MemFun,P1>(obj,mem_fun,p1);
}

template<bool cond, class Obj,typename MemFun,typename P1>
inline typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
make_obj_guard_if_c( Obj& obj,MemFun mem_fun,P1 p1)
{
  return typename null_guard_return<cond,obj_scope_guard_impl1<Obj,MemFun,P1> >::type(obj,mem_fun,p1);
}

template<typename C, class Obj,typename MemFun,typename P1>
inline typename null_guard_return<C::value,obj_scope_guard_impl1<Obj,MemFun,P1> >::type
make_obj_guard_if( Obj& obj,MemFun mem_fun,P1 p1)
{
  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1);
}

template<class Obj,typename MemFun,typename P1,typename P2>
class obj_scope_guard_impl2:public scope_guard_impl_base
{
public:
  obj_scope_guard_impl2(Obj& obj,MemFun mem_fun,P1 p1,P2 p2):
    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2)
  {}
  ~obj_scope_guard_impl2(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){(obj_.*mem_fun_)(p1_,p2_);}

protected:
  Obj& obj_;
  MemFun mem_fun_;
  const P1 p1_;
  const P2 p2_;
};

template<class Obj,typename MemFun,typename P1,typename P2>
inline obj_scope_guard_impl2<Obj,MemFun,P1,P2>
make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
{
  return obj_scope_guard_impl2<Obj,MemFun,P1,P2>(obj,mem_fun,p1,p2);
}

template<bool cond, class Obj,typename MemFun,typename P1,typename P2>
inline typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
{
  return typename null_guard_return<cond,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type(obj,mem_fun,p1,p2);
}

template<typename C, class Obj,typename MemFun,typename P1,typename P2>
inline typename null_guard_return<C::value,obj_scope_guard_impl2<Obj,MemFun,P1,P2> >::type
make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2)
{
  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2);
}

template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
class obj_scope_guard_impl3:public scope_guard_impl_base
{
public:
  obj_scope_guard_impl3(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3):
    obj_(obj),mem_fun_(mem_fun),p1_(p1),p2_(p2),p3_(p3)
  {}
  ~obj_scope_guard_impl3(){scope_guard_impl_base::safe_execute(*this);}
  void execute(){(obj_.*mem_fun_)(p1_,p2_,p3_);}

protected:
  Obj& obj_;
  MemFun mem_fun_;
  const P1 p1_;
  const P2 p2_;
  const P3 p3_;
};

template<class Obj,typename MemFun,typename P1,typename P2,typename P3>
inline obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>
make_obj_guard(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
{
  return obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3>(obj,mem_fun,p1,p2,p3);
}

template<bool cond, class Obj,typename MemFun,typename P1,typename P2,typename P3>
inline typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
make_obj_guard_if_c(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
{
  return typename null_guard_return<cond,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type(obj,mem_fun,p1,p2,p3);
}

template<typename C, class Obj,typename MemFun,typename P1,typename P2,typename P3>
inline typename null_guard_return<C::value,obj_scope_guard_impl3<Obj,MemFun,P1,P2,P3> >::type
make_obj_guard_if(Obj& obj,MemFun mem_fun,P1 p1,P2 p2,P3 p3)
{
  return make_obj_guard_if_c<C::value>(obj,mem_fun,p1,p2,p3);
}

}

}

}
# 41 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/utility/base_from_member.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/utility/base_from_member.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat_from_to.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2
# 17 "/opt/sevenflow/boost/include/boost/utility/base_from_member.hpp" 2
# 53 "/opt/sevenflow/boost/include/boost/utility/base_from_member.hpp"
namespace boost
{
# 65 "/opt/sevenflow/boost/include/boost/utility/base_from_member.hpp"
template < typename MemberType, int UniqueID = 0 >
class base_from_member
{
protected:
    MemberType member;

    base_from_member()
        : member()
        {}

    template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {} template < typename T0 , typename T1 > explicit base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}


};

}
# 44 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/archive_constructed.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/archive_constructed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/serialization.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/serialization/serialization.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/strong_typedef.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/serialization/serialization.hpp" 2
# 59 "/opt/sevenflow/boost/include/boost/serialization/serialization.hpp"
namespace boost {
namespace serialization {

struct version_type : boost::totally_ordered1< version_type , boost::totally_ordered2< version_type, unsigned int > > { unsigned int t; explicit version_type(const unsigned int t_) : t(t_) {}; version_type(): t() {}; version_type(const version_type & t_) : t(t_.t){} version_type & operator=(const version_type & rhs) { t = rhs.t; return *this;} version_type & operator=(const unsigned int & rhs) { t = rhs; return *this;} operator const unsigned int & () const {return t; } operator unsigned int & () { return t; } bool operator==(const version_type & rhs) const { return t == rhs.t; } bool operator<(const version_type & rhs) const { return t < rhs.t; } };


template<class Archive, class T>
inline void serialize(
    Archive & ar, T & t, const unsigned int file_version
){
    access::serialize(ar, t, static_cast<unsigned int>(file_version));
}


template<class Archive, class T>
inline void save_construct_data(
    Archive & ,
    const T * ,
    const unsigned int
){


}


template<class Archive, class T>
inline void load_construct_data(
    Archive & ,
    T * t,
    const unsigned int
){



    access::construct(t);
}
# 112 "/opt/sevenflow/boost/include/boost/serialization/serialization.hpp"
template<class Archive, class T>
inline void serialize_adl(
    Archive & ar,
    T & t,
    const unsigned int file_version
){
# 127 "/opt/sevenflow/boost/include/boost/serialization/serialization.hpp"
        const version_type v(file_version);
        serialize(ar, t, v);



}

template<class Archive, class T>
inline void save_construct_data_adl(
    Archive & ar,
    const T * t,
    const unsigned int file_version
){


        const version_type v(file_version);
        save_construct_data(ar, t, v);



}

template<class Archive, class T>
inline void load_construct_data_adl(
    Archive & ar,
    T * t,
    const unsigned int file_version
){


        const version_type v(file_version);
        load_construct_data(ar, t, v);



}

}
}
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/archive_constructed.hpp" 2



namespace boost{

namespace multi_index{

namespace detail{



template<typename T>
struct archive_constructed:private noncopyable
{
  template<class Archive>
  archive_constructed(Archive& ar,const unsigned int version)
  {
    serialization::load_construct_data_adl(ar,&get(),version);
    { try{
      ar>>get();
    }
    catch(...){
      (&get())->~T();
      throw;;
    }
    }
  }

  template<class Archive>
  archive_constructed(const char* name,Archive& ar,const unsigned int version)
  {
    serialization::load_construct_data_adl(ar,&get(),version);
    { try{
      ar>>serialization::make_nvp(name,get());
    }
    catch(...){
      (&get())->~T();
      throw;;
    }
    }
  }

  ~archive_constructed()
  {
    (&get())->~T();
  }

  T& get(){return *static_cast<T*>(static_cast<void*>(&space));}

private:
  typename aligned_storage<sizeof(T),alignment_of<T>::value>::type space;
};

}

}

}
# 47 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/serialization_version.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/serialization_version.hpp"
# 1 "/opt/sevenflow/boost/include/boost/serialization/version.hpp" 1
# 28 "/opt/sevenflow/boost/include/boost/serialization/version.hpp"
namespace boost {
namespace serialization {

struct basic_traits;



template<class T>
struct version
{
    template<class U>
    struct traits_class_version {
        typedef typename U::version type;
    };

    typedef mpl::integral_c_tag tag;


    typedef
        typename mpl::eval_if<
            is_base_and_derived<boost::serialization::basic_traits,T>,
            traits_class_version< T >,
            mpl::int_<0>
        >::type type;
    static const int value = version::type::value;
};


template<class T>
const int version<T>::value;


}
}
# 76 "/opt/sevenflow/boost/include/boost/serialization/version.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/comparison.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/mpl/comparison.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/not_equal_to.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/not_equal_to.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/not_equal_to.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/mpl/comparison.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/mpl/less_equal.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/less_equal.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/less_equal.hpp" 2
# 22 "/opt/sevenflow/boost/include/boost/mpl/comparison.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/mpl/greater_equal.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/mpl/greater_equal.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply_wrap.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/mpl/aux_/numeric_op.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2







# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 1
# 37 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp"
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 "/opt/sevenflow/boost/include/boost/mpl/aux_/include_preprocessed.hpp" 2
# 36 "/opt/sevenflow/boost/include/boost/mpl/aux_/comparison_op.hpp" 2
# 20 "/opt/sevenflow/boost/include/boost/mpl/greater_equal.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/mpl/comparison.hpp" 2
# 77 "/opt/sevenflow/boost/include/boost/serialization/version.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/serialization_version.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{







template<typename T>
struct serialization_version
{
  serialization_version():
    value(boost::serialization::version<serialization_version>::value){}

  serialization_version& operator=(unsigned int x){value=x;return *this;};

  operator unsigned int()const{return value;}

private:
  friend class boost::serialization::access;

  template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }

  template<class Archive>
  void save(Archive&,const unsigned int)const{}

  template<class Archive>
  void load(Archive&,const unsigned int version)
  {
    this->value=version;
  }

  unsigned int value;
};

}

}


namespace serialization {
template<typename T>
struct version<boost::multi_index::detail::serialization_version<T> >
{
  static const int value=version<T>::value;
};
}


}
# 48 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/collection_size_type.hpp" 1
# 9 "/opt/sevenflow/boost/include/boost/serialization/collection_size_type.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 10 "/opt/sevenflow/boost/include/boost/serialization/collection_size_type.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/serialization/split_free.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/serialization/split_free.hpp"
namespace boost {
namespace archive {
    namespace detail {
        template<class Archive> class interface_oarchive;
        template<class Archive> class interface_iarchive;
    }
}

namespace serialization {


template<class Archive, class T>
struct free_saver {
    static void invoke(
        Archive & ar,
        const T & t,
        const unsigned int file_version
    ){


        const version_type v(file_version);
        save(ar, t, v);
    }
};
template<class Archive, class T>
struct free_loader {
    static void invoke(
        Archive & ar,
        T & t,
        const unsigned int file_version
    ){


        const version_type v(file_version);
        load(ar, t, v);
    }
};


template<class Archive, class T>
inline void split_free(
    Archive & ar,
    T & t,
    const unsigned int file_version
){
    typedef typename mpl::eval_if<
        typename Archive::is_saving,
        mpl::identity< free_saver<Archive, T> >,
        mpl::identity< free_loader<Archive, T> >
    >::type typex;
    typex::invoke(ar, t, file_version);
}

}
}
# 13 "/opt/sevenflow/boost/include/boost/serialization/collection_size_type.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/serialization/is_bitwise_serializable.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/serialization/is_bitwise_serializable.hpp"
namespace boost {
namespace serialization {
    template<class T>
    struct is_bitwise_serializable
     : public is_arithmetic< T >
    {};
}
}
# 14 "/opt/sevenflow/boost/include/boost/serialization/collection_size_type.hpp" 2

namespace boost {
namespace serialization {



class collection_size_type {
private:
    typedef std::size_t base_type;
    base_type t;
public:
    collection_size_type(): t(0) {};
    explicit collection_size_type(const std::size_t & t_) :
        t(t_)
    {}
    collection_size_type(const collection_size_type & t_) :
        t(t_.t)
    {}
    collection_size_type & operator=(const collection_size_type & rhs){
        t = rhs.t;
        return *this;
    }
    collection_size_type & operator=(const unsigned int & rhs){
        t = rhs;
        return *this;
    }

    operator base_type () const {
        return t;
    }

    operator base_type & () {
        return t;
    }
    bool operator==(const collection_size_type & rhs) const {
        return t == rhs.t;
    }
    bool operator<(const collection_size_type & rhs) const {
        return t < rhs.t;
    }
};


} }

namespace boost { namespace serialization { template <> struct implementation_level_impl< const collection_size_type > { typedef mpl::integral_c_tag tag; typedef mpl::int_< primitive_type > type; static const int value = implementation_level_impl::type::value; }; } }
namespace boost { namespace serialization { template<> struct is_bitwise_serializable< collection_size_type > : mpl::true_ {}; }}
# 49 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp" 2
# 65 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
namespace boost{

namespace multi_index{

template<typename Value,typename IndexSpecifierList,typename Allocator>
class multi_index_container:
  private ::boost::base_from_member<
    typename boost::detail::allocator::rebind_to<
      Allocator,
      typename detail::multi_index_node_type<
        Value,IndexSpecifierList,Allocator>::type
    >::type>,
  private detail::header_holder<
    typename detail::prevent_eti<
      Allocator,
      typename boost::detail::allocator::rebind_to<
        Allocator,
        typename detail::multi_index_node_type<
          Value,IndexSpecifierList,Allocator>::type
      >::type
    >::type::pointer,
    multi_index_container<Value,IndexSpecifierList,Allocator> >,
  public detail::multi_index_base_type<
    Value,IndexSpecifierList,Allocator>::type
{
# 100 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
private:

  template <typename,typename,typename> friend class detail::index_base;
  template <typename,typename> friend struct detail::header_holder;
  template <typename,typename> friend struct detail::converter;


  typedef typename detail::multi_index_base_type<
      Value,IndexSpecifierList,Allocator>::type super;
  typedef typename
  boost::detail::allocator::rebind_to<
      Allocator,
      typename super::node_type
  >::type node_allocator;
  typedef ::boost::base_from_member<
    node_allocator> bfm_allocator;
  typedef detail::header_holder<
    typename detail::prevent_eti<
      Allocator,
      node_allocator
    >::type::pointer,
    multi_index_container> bfm_header;






public:




  typedef typename super::ctor_args_list ctor_args_list;
  typedef IndexSpecifierList index_specifier_type_list;
# 155 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
  typedef typename super::index_type_list index_type_list;


  typedef typename super::iterator_type_list iterator_type_list;
  typedef typename super::const_iterator_type_list const_iterator_type_list;
  typedef typename super::value_type value_type;
  typedef typename super::final_allocator_type allocator_type;
  typedef typename super::iterator iterator;
  typedef typename super::const_iterator const_iterator;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((detail::no_duplicate_tags_in_index_list<index_type_list>::value) == 0 ? false : true) >)> boost_static_assert_typedef_166
                                                                    ;



  typedef typename super::node_type node_type;



  explicit multi_index_container(
# 188 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
    const ctor_args_list& args_list=ctor_args_list(),
    const allocator_type& al=allocator_type()):


    bfm_allocator(al),
    super(args_list,bfm_allocator::member),
    node_count(0)
  {
    ;
  }

  explicit multi_index_container(const allocator_type& al):
    bfm_allocator(al),
    super(ctor_args_list(),bfm_allocator::member),
    node_count(0)
  {
    ;
  }

  template<typename InputIterator>
  multi_index_container(
    InputIterator first,InputIterator last,
# 223 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
    const ctor_args_list& args_list=ctor_args_list(),
    const allocator_type& al=allocator_type()):


    bfm_allocator(al),
    super(args_list,bfm_allocator::member),
    node_count(0)
  {
    ;
    { try{
      iterator hint=super::end();
      for(;first!=last;++first){
        hint=super::make_iterator(insert_(*first,hint.get_node()).first);
      }
    }
    catch(...){
      clear_();
      throw;;
    }
    }
  }

  multi_index_container(
    const multi_index_container<Value,IndexSpecifierList,Allocator>& x):
    bfm_allocator(x.bfm_allocator::member),
    bfm_header(),
    super(x),
    node_count(0)
  {
    copy_map_type map(bfm_allocator::member,x.size(),x.header(),header());
    for(const_iterator it=x.begin(),it_end=x.end();it!=it_end;++it){
      map.clone(it.get_node());
    }
    super::copy_(x,map);
    map.release();
    node_count=x.size();





    ;
  }

  ~multi_index_container()
  {
    delete_all_nodes_();
  }

  multi_index_container<Value,IndexSpecifierList,Allocator>& operator=(
    multi_index_container<Value,IndexSpecifierList,Allocator> x)
  {
    ;
    this->swap(x);
    return *this;
  }

  allocator_type get_allocator()const
  {
    return allocator_type(bfm_allocator::member);
  }




  template<int N>
  struct nth_index
  {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((N>=0&&N<mpl::size<index_type_list>::type::value) == 0 ? false : true) >)> boost_static_assert_typedef_291;
    typedef typename mpl::at_c<index_type_list,N>::type type;
  };

  template<int N>
  typename nth_index<N>::type& get()
  {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((N>=0&&N<mpl::size<index_type_list>::type::value) == 0 ? false : true) >)> boost_static_assert_typedef_298;
    return *this;
  }

  template<int N>
  const typename nth_index<N>::type& get(
    )const
  {
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((N>=0&&N<mpl::size<index_type_list>::type::value) == 0 ? false : true) >)> boost_static_assert_typedef_306;
    return *this;
  }





  template<typename Tag>
  struct index
  {
    typedef typename mpl::find_if<
      index_type_list,
      detail::has_tag<Tag>
    >::type iter;

    static const bool index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value)
                                                                                         ;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((index_found) == 0 ? false : true) >)> boost_static_assert_typedef_324;

    typedef typename mpl::deref<iter>::type type;
  };

  template<typename Tag>
  typename index<Tag>::type& get()
  {
    return *this;
  }

  template<typename Tag>
  const typename index<Tag>::type& get(
    )const
  {
    return *this;
  }





  template<int N>
  struct nth_index_iterator
  {
    typedef typename nth_index<N>::type::iterator type;
  };

  template<int N>
  struct nth_index_const_iterator
  {
    typedef typename nth_index<N>::type::const_iterator type;
  };

  template<int N,typename IteratorType>
  typename nth_index_iterator<N>::type project(
    IteratorType it
    )
  {
    typedef typename nth_index<N>::type index;


    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((mpl::contains<iterator_type_list,IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_367
                                                              ;


    ((void)0);;
    ((void)0);
                                                                    ;

    return index::make_iterator(static_cast<node_type*>(it.get_node()));
  }

  template<int N,typename IteratorType>
  typename nth_index_const_iterator<N>::type project(
    IteratorType it
    )const
  {
    typedef typename nth_index<N>::type index;


    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( mpl::contains<iterator_type_list,IteratorType>::value|| mpl::contains<const_iterator_type_list,IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_387

                                                                   ;


    ((void)0);;
    ((void)0);
                                                                          ;
    return index::make_iterator(static_cast<node_type*>(it.get_node()));
  }





  template<typename Tag>
  struct index_iterator
  {
    typedef typename index<Tag>::type::iterator type;
  };

  template<typename Tag>
  struct index_const_iterator
  {
    typedef typename index<Tag>::type::const_iterator type;
  };

  template<typename Tag,typename IteratorType>
  typename index_iterator<Tag>::type project(
    IteratorType it
    )
  {
    typedef typename index<Tag>::type index;


    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((mpl::contains<iterator_type_list,IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_421
                                                              ;


    ((void)0);;
    ((void)0);
                                                                    ;
    return index::make_iterator(static_cast<node_type*>(it.get_node()));
  }

  template<typename Tag,typename IteratorType>
  typename index_const_iterator<Tag>::type project(
    IteratorType it
    )const
  {
    typedef typename index<Tag>::type index;


    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( mpl::contains<iterator_type_list,IteratorType>::value|| mpl::contains<const_iterator_type_list,IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_440

                                                                   ;


    ((void)0);;
    ((void)0);
                                                                          ;
    return index::make_iterator(static_cast<node_type*>(it.get_node()));
  }


protected:
  typedef typename super::copy_map_type copy_map_type;

  node_type* header()const
  {
    return &*bfm_header::member;
  }

  node_type* allocate_node()
  {
    return &*bfm_allocator::member.allocate(1);
  }

  void deallocate_node(node_type* x)
  {
    typedef typename node_allocator::pointer node_pointer;
    bfm_allocator::member.deallocate(static_cast<node_pointer>(x),1);
  }

  bool empty_()const
  {
    return node_count==0;
  }

  std::size_t size_()const
  {
    return node_count;
  }

  std::size_t max_size_()const
  {
    return static_cast<std::size_t >(-1);
  }

  std::pair<node_type*,bool> insert_(const Value& v)
  {
    node_type* x=allocate_node();
    { try{
      node_type* res=super::insert_(v,x);
      if(res==x){
        ++node_count;
        return std::pair<node_type*,bool>(res,true);
      }
      else{
        deallocate_node(x);
        return std::pair<node_type*,bool>(res,false);
      }
    }
    catch(...){
      deallocate_node(x);
      throw;;
    }
    }
  }

  std::pair<node_type*,bool> insert_(const Value& v,node_type* position)
  {
    node_type* x=allocate_node();
    { try{
      node_type* res=super::insert_(v,position,x);
      if(res==x){
        ++node_count;
        return std::pair<node_type*,bool>(res,true);
      }
      else{
        deallocate_node(x);
        return std::pair<node_type*,bool>(res,false);
      }
    }
    catch(...){
      deallocate_node(x);
      throw;;
    }
    }
  }

  void erase_(node_type* x)
  {
    --node_count;
    super::erase_(x);
    deallocate_node(x);
  }

  void delete_node_(node_type* x)
  {
    super::delete_node_(x);
    deallocate_node(x);
  }

  void delete_all_nodes_()
  {
    super::delete_all_nodes_();
  }

  void clear_()
  {
    delete_all_nodes_();
    super::clear_();
    node_count=0;
  }

  void swap_(multi_index_container<Value,IndexSpecifierList,Allocator>& x)
  {
    if(bfm_allocator::member!=x.bfm_allocator::member){
      detail::adl_swap(bfm_allocator::member,x.bfm_allocator::member);
    }
    std::swap(bfm_header::member,x.bfm_header::member);
    super::swap_(x);
    std::swap(node_count,x.node_count);
  }

  bool replace_(const Value& k,node_type* x)
  {
    return super::replace_(k,x);
  }

  template<typename Modifier>
  bool modify_(Modifier& mod,node_type* x)
  {
    mod(const_cast<value_type&>(x->value()));

    { try{
      if(!super::modify_(x)){
        deallocate_node(x);
        --node_count;
        return false;
      }
      else return true;
    }
    catch(...){
      deallocate_node(x);
      --node_count;
      throw;;
    }
    }
  }

  template<typename Modifier,typename Rollback>
  bool modify_(Modifier& mod,Rollback& back,node_type* x)
  {
    mod(const_cast<value_type&>(x->value()));

    bool b;
    { try{
      b=super::modify_rollback_(x);
    }
    catch(...){
      { try{
        back(const_cast<value_type&>(x->value()));
        throw;;
      }
      catch(...){
        this->erase_(x);
        throw;;
      }
      }
    }
    }

    { try{
      if(!b){
        back(const_cast<value_type&>(x->value()));
        return false;
      }
      else return true;
    }
    catch(...){
      this->erase_(x);
      throw;;
    }
    }
  }




  friend class boost::serialization::access;

  template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }

  typedef typename super::index_saver_type index_saver_type;
  typedef typename super::index_loader_type index_loader_type;

  template<class Archive>
  void save(Archive& ar,const unsigned int version)const
  {


    const serialization::collection_size_type s(size_());
    const detail::serialization_version<value_type> value_version;
    ar<<serialization::make_nvp("count",s);
    ar<<serialization::make_nvp("value_version",value_version);






    index_saver_type sm(bfm_allocator::member,s);

    for(iterator it=super::begin(),it_end=super::end();it!=it_end;++it){
      serialization::save_construct_data_adl(ar,&*it,value_version);
      ar<<serialization::make_nvp("item",*it);
      sm.add(it.get_node(),ar,version);
    }
    sm.add_track(header(),ar,version);

    super::save_(ar,version,sm);
  }

  template<class Archive>
  void load(Archive& ar,const unsigned int version)
  {
    ;

    clear_();


    serialization::collection_size_type s;
    detail::serialization_version<value_type> value_version;
    if(version<1){
      std::size_t sz;
      ar>>serialization::make_nvp("count",sz);
      s=static_cast<serialization::collection_size_type>(sz);
    }
    else{
      ar>>serialization::make_nvp("count",s);
    }
    if(version<2){
      value_version=0;
    }
    else{
      ar>>serialization::make_nvp("value_version",value_version);
    }






    index_loader_type lm(bfm_allocator::member,s);

    for(std::size_t n=0;n<s;++n){
      detail::archive_constructed<Value> value("item",ar,value_version);
      std::pair<node_type*,bool> p=insert_(
        value.get(),super::end().get_node());
      if(!p.second)throw_exception(
        archive::archive_exception(
          archive::archive_exception::other_exception));
      ar.reset_object_address(&p.first->value(),&value.get());
      lm.add(p.first,ar,version);
    }
    lm.add_track(header(),ar,version);

    super::load_(ar,version,lm);
  }
# 722 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
private:
  std::size_t node_count;





};



template<typename MultiIndexContainer,int N>
struct nth_index
{
  static const int M=mpl::size<typename MultiIndexContainer::index_type_list>::type::value

                                                                            ;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((N>=0&&N<M) == 0 ? false : true) >)> boost_static_assert_typedef_739;
  typedef typename mpl::at_c<
    typename MultiIndexContainer::index_type_list,N>::type type;
};

template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
typename nth_index<
  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
get(
  multi_index_container<Value,IndexSpecifierList,Allocator>& m
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename nth_index<
    multi_index_container<
      Value,IndexSpecifierList,Allocator>,
    N
  >::type index;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((N>=0&& N< mpl::size< typename multi_index_type::index_type_list >::type::value) == 0 ? false : true) >)> boost_static_assert_typedef_763



                   ;

  return detail::converter<multi_index_type,index>::index(m);
}

template<int N,typename Value,typename IndexSpecifierList,typename Allocator>
const typename nth_index<
  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type&
get(
  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename nth_index<
    multi_index_container<
      Value,IndexSpecifierList,Allocator>,
    N
  >::type index;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((N>=0&& N< mpl::size< typename multi_index_type::index_type_list >::type::value) == 0 ? false : true) >)> boost_static_assert_typedef_787



                   ;

  return detail::converter<multi_index_type,index>::index(m);
}



template<typename MultiIndexContainer,typename Tag>
struct index
{
  typedef typename MultiIndexContainer::index_type_list index_type_list;

  typedef typename mpl::find_if<
    index_type_list,
    detail::has_tag<Tag>
  >::type iter;

  static const bool index_found=!(is_same<iter,typename mpl::end<index_type_list>::type >::value)
                                                                                       ;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((index_found) == 0 ? false : true) >)> boost_static_assert_typedef_806;

  typedef typename mpl::deref<iter>::type type;
};

template<
  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
>
typename ::boost::multi_index::index<
  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
get(
  multi_index_container<Value,IndexSpecifierList,Allocator>& m
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename ::boost::multi_index::index<
    multi_index_container<
      Value,IndexSpecifierList,Allocator>,
    Tag
  >::type index;

  return detail::converter<multi_index_type,index>::index(m);
}

template<
  typename Tag,typename Value,typename IndexSpecifierList,typename Allocator
>
const typename ::boost::multi_index::index<
  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type&
get(
  const multi_index_container<Value,IndexSpecifierList,Allocator>& m
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename ::boost::multi_index::index<
    multi_index_container<
      Value,IndexSpecifierList,Allocator>,
    Tag
  >::type index;

  return detail::converter<multi_index_type,index>::index(m);
}



template<typename MultiIndexContainer,int N>
struct nth_index_iterator
{
  typedef typename detail::prevent_eti<
    nth_index<MultiIndexContainer,N>,
    typename nth_index<MultiIndexContainer,N>::type>::type::iterator type;
};

template<typename MultiIndexContainer,int N>
struct nth_index_const_iterator
{
  typedef typename detail::prevent_eti<
    nth_index<MultiIndexContainer,N>,
    typename nth_index<MultiIndexContainer,N>::type
  >::type::const_iterator type;
};

template<
  int N,typename IteratorType,
  typename Value,typename IndexSpecifierList,typename Allocator>
typename nth_index_iterator<
  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
project(
  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
  IteratorType it
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename nth_index<multi_index_type,N>::type index;



  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_889


                            ;


  ((void)0);;
# 901 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
  return detail::converter<multi_index_type,index>::iterator(
    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}

template<
  int N,typename IteratorType,
  typename Value,typename IndexSpecifierList,typename Allocator>
typename nth_index_const_iterator<
  multi_index_container<Value,IndexSpecifierList,Allocator>,N>::type
project(
  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
  IteratorType it
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename nth_index<multi_index_type,N>::type index;



  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< typename multi_index_type::const_iterator_type_list, IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_927





                            ;


  ((void)0);;
# 939 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
  return detail::converter<multi_index_type,index>::const_iterator(
    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}



template<typename MultiIndexContainer,typename Tag>
struct index_iterator
{
  typedef typename ::boost::multi_index::index<
    MultiIndexContainer,Tag>::type::iterator type;
};

template<typename MultiIndexContainer,typename Tag>
struct index_const_iterator
{
  typedef typename ::boost::multi_index::index<
    MultiIndexContainer,Tag>::type::const_iterator type;
};

template<
  typename Tag,typename IteratorType,
  typename Value,typename IndexSpecifierList,typename Allocator>
typename index_iterator<
  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
project(
  multi_index_container<Value,IndexSpecifierList,Allocator>& m,
  IteratorType it
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename ::boost::multi_index::index<
    multi_index_type,Tag>::type index;



  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_979


                            ;


  ((void)0);;
# 991 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
  return detail::converter<multi_index_type,index>::iterator(
    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}

template<
  typename Tag,typename IteratorType,
  typename Value,typename IndexSpecifierList,typename Allocator>
typename index_const_iterator<
  multi_index_container<Value,IndexSpecifierList,Allocator>,Tag>::type
project(
  const multi_index_container<Value,IndexSpecifierList,Allocator>& m,
  IteratorType it
  )
{
  typedef multi_index_container<
    Value,IndexSpecifierList,Allocator> multi_index_type;
  typedef typename ::boost::multi_index::index<
    multi_index_type,Tag>::type index;



  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( mpl::contains< typename multi_index_type::iterator_type_list, IteratorType>::value|| mpl::contains< typename multi_index_type::const_iterator_type_list, IteratorType>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_1018





                            ;


  ((void)0);;
# 1030 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
  return detail::converter<multi_index_type,index>::const_iterator(
    m,static_cast<typename multi_index_type::node_type*>(it.get_node()));
}



template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator==(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
{
  return get<0>(x)==get<0>(y);
}

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator<(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
{
  return get<0>(x)<get<0>(y);
}

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator!=(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
{
  return get<0>(x)!=get<0>(y);
}

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator>(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
{
  return get<0>(x)>get<0>(y);
}

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator>=(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
{
  return get<0>(x)>=get<0>(y);
}

template<
  typename Value1,typename IndexSpecifierList1,typename Allocator1,
  typename Value2,typename IndexSpecifierList2,typename Allocator2
>
bool operator<=(
  const multi_index_container<Value1,IndexSpecifierList1,Allocator1>& x,
  const multi_index_container<Value2,IndexSpecifierList2,Allocator2>& y)
{
  return get<0>(x)<=get<0>(y);
}



template<typename Value,typename IndexSpecifierList,typename Allocator>
void swap(
  multi_index_container<Value,IndexSpecifierList,Allocator>& x,
  multi_index_container<Value,IndexSpecifierList,Allocator>& y)
{
  x.swap(y);
}

}
# 1121 "/opt/sevenflow/boost/include/boost/multi_index_container.hpp"
namespace serialization {
template<typename Value,typename IndexSpecifierList,typename Allocator>
struct version<
  boost::multi_index_container<Value,IndexSpecifierList,Allocator>
>
{
  static const int value=2;
};
}






using multi_index::get;
using multi_index::project;

}
# 3 "test.cpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash_fwd.hpp" 1





# 1 "/opt/sevenflow/boost/include/boost/functional/hash/hash_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/functional/hash/hash_fwd.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 19 "/opt/sevenflow/boost/include/boost/functional/hash/hash_fwd.hpp" 2


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 "/opt/sevenflow/boost/include/boost/functional/hash_fwd.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/at.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/list/at.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/list/rest_n.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/list/at.hpp" 2
# 28 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp" 2
# 107 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
namespace boost{

template<class T> class reference_wrapper;

namespace multi_index{

namespace detail{



template<typename CompositeKey,int N>
struct nth_key_from_value
{
  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
  typedef typename prevent_eti<
    tuples::element<N,key_extractor_tuple>,
    typename mpl::eval_if_c<
      N<tuples::length<key_extractor_tuple>::value,
      tuples::element<N,key_extractor_tuple>,
      mpl::identity<tuples::null_type>
    >::type
  >::type type;
};
# 162 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename KeyFromValue> struct key_equal_to { typedef std::equal_to<typename KeyFromValue::result_type> type; }; template<> struct key_equal_to<tuples::null_type> { typedef tuples::null_type type; }; template<typename CompositeKey,int N> struct nth_composite_key_equal_to { typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value; typedef typename key_equal_to<key_from_value>::type type; };
template<typename KeyFromValue> struct key_less { typedef std::less<typename KeyFromValue::result_type> type; }; template<> struct key_less<tuples::null_type> { typedef tuples::null_type type; }; template<typename CompositeKey,int N> struct nth_composite_key_less { typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value; typedef typename key_less<key_from_value>::type type; };
template<typename KeyFromValue> struct key_greater { typedef std::greater<typename KeyFromValue::result_type> type; }; template<> struct key_greater<tuples::null_type> { typedef tuples::null_type type; }; template<typename CompositeKey,int N> struct nth_composite_key_greater { typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value; typedef typename key_greater<key_from_value>::type type; };
template<typename KeyFromValue> struct key_hash { typedef boost::hash<typename KeyFromValue::result_type> type; }; template<> struct key_hash<tuples::null_type> { typedef tuples::null_type type; }; template<typename CompositeKey,int N> struct nth_composite_key_hash { typedef typename nth_key_from_value<CompositeKey,N>::type key_from_value; typedef typename key_hash<key_from_value>::type type; };





struct generic_operator_equal
{
  template<typename T,typename Q>
  bool operator()(const T& x,const Q& y)const{return x==y;}
};

typedef tuple<
  detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal , detail::generic_operator_equal

                                   > generic_operator_equal_tuple;

struct generic_operator_less
{
  template<typename T,typename Q>
  bool operator()(const T& x,const Q& y)const{return x<y;}
};

typedef tuple<
  detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less , detail::generic_operator_less

                                  > generic_operator_less_tuple;
# 202 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename EqualCons
>
struct equal_ckey_ckey;

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename EqualCons
>
struct equal_ckey_ckey_terminal
{
  static bool compare(
    const KeyCons1&,const Value1&,
    const KeyCons2&,const Value2&,
    const EqualCons&)
  {
    return true;
  }
};

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename EqualCons
>
struct equal_ckey_ckey_normal
{
  static bool compare(
    const KeyCons1& c0,const Value1& v0,
    const KeyCons2& c1,const Value2& v1,
    const EqualCons& eq)
  {
    if(!eq.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return false;
    return equal_ckey_ckey<
      typename KeyCons1::tail_type,Value1,
      typename KeyCons2::tail_type,Value2,
      typename EqualCons::tail_type
    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,eq.get_tail());
  }
};

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename EqualCons
>
struct equal_ckey_ckey:
  mpl::if_<
    mpl::or_<
      is_same<KeyCons1,tuples::null_type>,
      is_same<KeyCons2,tuples::null_type>
    >,
    equal_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>,
    equal_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,EqualCons>
  >::type
{
};

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename EqualCons
>
struct equal_ckey_cval;

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename EqualCons
>
struct equal_ckey_cval_terminal
{
  static bool compare(
    const KeyCons&,const Value&,const ValCons&,const EqualCons&)
  {
    return true;
  }

  static bool compare(
    const ValCons&,const KeyCons&,const Value&,const EqualCons&)
  {
    return true;
  }
};

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename EqualCons
>
struct equal_ckey_cval_normal
{
  static bool compare(
    const KeyCons& c,const Value& v,const ValCons& vc,
    const EqualCons& eq)
  {
    if(!eq.get_head()(c.get_head()(v),vc.get_head()))return false;
    return equal_ckey_cval<
      typename KeyCons::tail_type,Value,
      typename ValCons::tail_type,
      typename EqualCons::tail_type
    >::compare(c.get_tail(),v,vc.get_tail(),eq.get_tail());
  }

  static bool compare(
    const ValCons& vc,const KeyCons& c,const Value& v,
    const EqualCons& eq)
  {
    if(!eq.get_head()(vc.get_head(),c.get_head()(v)))return false;
    return equal_ckey_cval<
      typename KeyCons::tail_type,Value,
      typename ValCons::tail_type,
      typename EqualCons::tail_type
    >::compare(vc.get_tail(),c.get_tail(),v,eq.get_tail());
  }
};

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename EqualCons
>
struct equal_ckey_cval:
  mpl::if_<
    mpl::or_<
      is_same<KeyCons,tuples::null_type>,
      is_same<ValCons,tuples::null_type>
    >,
    equal_ckey_cval_terminal<KeyCons,Value,ValCons,EqualCons>,
    equal_ckey_cval_normal<KeyCons,Value,ValCons,EqualCons>
  >::type
{
};

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename CompareCons
>
struct compare_ckey_ckey;

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename CompareCons
>
struct compare_ckey_ckey_terminal
{
  static bool compare(
    const KeyCons1&,const Value1&,
    const KeyCons2&,const Value2&,
    const CompareCons&)
  {
    return false;
  }
};

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename CompareCons
>
struct compare_ckey_ckey_normal
{
  static bool compare(
    const KeyCons1& c0,const Value1& v0,
    const KeyCons2& c1,const Value2& v1,
    const CompareCons& comp)
  {
    if(comp.get_head()(c0.get_head()(v0),c1.get_head()(v1)))return true;
    if(comp.get_head()(c1.get_head()(v1),c0.get_head()(v0)))return false;
    return compare_ckey_ckey<
      typename KeyCons1::tail_type,Value1,
      typename KeyCons2::tail_type,Value2,
      typename CompareCons::tail_type
    >::compare(c0.get_tail(),v0,c1.get_tail(),v1,comp.get_tail());
  }
};

template
<
  typename KeyCons1,typename Value1,
  typename KeyCons2, typename Value2,
  typename CompareCons
>
struct compare_ckey_ckey:
  mpl::if_<
    mpl::or_<
      is_same<KeyCons1,tuples::null_type>,
      is_same<KeyCons2,tuples::null_type>
    >,
    compare_ckey_ckey_terminal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>,
    compare_ckey_ckey_normal<KeyCons1,Value1,KeyCons2,Value2,CompareCons>
  >::type
{
};

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename CompareCons
>
struct compare_ckey_cval;

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename CompareCons
>
struct compare_ckey_cval_terminal
{
  static bool compare(
    const KeyCons&,const Value&,const ValCons&,const CompareCons&)
  {
    return false;
  }

  static bool compare(
    const ValCons&,const KeyCons&,const Value&,const CompareCons&)
  {
    return false;
  }
};

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename CompareCons
>
struct compare_ckey_cval_normal
{
  static bool compare(
    const KeyCons& c,const Value& v,const ValCons& vc,
    const CompareCons& comp)
  {
    if(comp.get_head()(c.get_head()(v),vc.get_head()))return true;
    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return false;
    return compare_ckey_cval<
      typename KeyCons::tail_type,Value,
      typename ValCons::tail_type,
      typename CompareCons::tail_type
    >::compare(c.get_tail(),v,vc.get_tail(),comp.get_tail());
  }

  static bool compare(
    const ValCons& vc,const KeyCons& c,const Value& v,
    const CompareCons& comp)
  {
    if(comp.get_head()(vc.get_head(),c.get_head()(v)))return true;
    if(comp.get_head()(c.get_head()(v),vc.get_head()))return false;
    return compare_ckey_cval<
      typename KeyCons::tail_type,Value,
      typename ValCons::tail_type,
      typename CompareCons::tail_type
    >::compare(vc.get_tail(),c.get_tail(),v,comp.get_tail());
  }
};

template
<
  typename KeyCons,typename Value,
  typename ValCons,typename CompareCons
>
struct compare_ckey_cval:
  mpl::if_<
    mpl::or_<
      is_same<KeyCons,tuples::null_type>,
      is_same<ValCons,tuples::null_type>
    >,
    compare_ckey_cval_terminal<KeyCons,Value,ValCons,CompareCons>,
    compare_ckey_cval_normal<KeyCons,Value,ValCons,CompareCons>
  >::type
{
};

template<typename KeyCons,typename Value,typename HashCons>
struct hash_ckey;

template<typename KeyCons,typename Value,typename HashCons>
struct hash_ckey_terminal
{
  static std::size_t hash(
    const KeyCons&,const Value&,const HashCons&,std::size_t carry)
  {
    return carry;
  }
};

template<typename KeyCons,typename Value,typename HashCons>
struct hash_ckey_normal
{
  static std::size_t hash(
    const KeyCons& c,const Value& v,const HashCons& h,std::size_t carry=0)
  {


    carry^=h.get_head()(c.get_head()(v))+0x9e3779b9+(carry<<6)+(carry>>2);
    return hash_ckey<
      typename KeyCons::tail_type,Value,
      typename HashCons::tail_type
    >::hash(c.get_tail(),v,h.get_tail(),carry);
  }
};

template<typename KeyCons,typename Value,typename HashCons>
struct hash_ckey:
  mpl::if_<
    is_same<KeyCons,tuples::null_type>,
    hash_ckey_terminal<KeyCons,Value,HashCons>,
    hash_ckey_normal<KeyCons,Value,HashCons>
  >::type
{
};

template<typename ValCons,typename HashCons>
struct hash_cval;

template<typename ValCons,typename HashCons>
struct hash_cval_terminal
{
  static std::size_t hash(const ValCons&,const HashCons&,std::size_t carry)
  {
    return carry;
  }
};

template<typename ValCons,typename HashCons>
struct hash_cval_normal
{
  static std::size_t hash(
    const ValCons& vc,const HashCons& h,std::size_t carry=0)
  {
    carry^=h.get_head()(vc.get_head())+0x9e3779b9+(carry<<6)+(carry>>2);
    return hash_cval<
      typename ValCons::tail_type,
      typename HashCons::tail_type
    >::hash(vc.get_tail(),h.get_tail(),carry);
  }
};

template<typename ValCons,typename HashCons>
struct hash_cval:
  mpl::if_<
    is_same<ValCons,tuples::null_type>,
    hash_cval_terminal<ValCons,HashCons>,
    hash_cval_normal<ValCons,HashCons>
  >::type
{
};

}
# 571 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename CompositeKey>
struct composite_key_result
{
  typedef CompositeKey composite_key_type;
  typedef typename composite_key_type::value_type value_type;

  composite_key_result(
    const composite_key_type& composite_key_,const value_type& value_):
    composite_key(composite_key_),value(value_)
  {}

  const composite_key_type& composite_key;
  const value_type& value;
};
# 602 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<
  typename Value,
  typename KeyFromValue0 , typename KeyFromValue1 =tuples::null_type , typename KeyFromValue2 =tuples::null_type , typename KeyFromValue3 =tuples::null_type , typename KeyFromValue4 =tuples::null_type , typename KeyFromValue5 =tuples::null_type , typename KeyFromValue6 =tuples::null_type , typename KeyFromValue7 =tuples::null_type , typename KeyFromValue8 =tuples::null_type , typename KeyFromValue9 =tuples::null_type
>
struct composite_key:
  private tuple< KeyFromValue0 , KeyFromValue1 , KeyFromValue2 , KeyFromValue3 , KeyFromValue4 , KeyFromValue5 , KeyFromValue6 , KeyFromValue7 , KeyFromValue8 , KeyFromValue9>
{
private:
  typedef tuple< KeyFromValue0 , KeyFromValue1 , KeyFromValue2 , KeyFromValue3 , KeyFromValue4 , KeyFromValue5 , KeyFromValue6 , KeyFromValue7 , KeyFromValue8 , KeyFromValue9> super;

public:
  typedef super key_extractor_tuple;
  typedef Value value_type;
  typedef composite_key_result<composite_key> result_type;

  composite_key(
    const KeyFromValue0& k0 = KeyFromValue0() , const KeyFromValue1& k1 = KeyFromValue1() , const KeyFromValue2& k2 = KeyFromValue2() , const KeyFromValue3& k3 = KeyFromValue3() , const KeyFromValue4& k4 = KeyFromValue4() , const KeyFromValue5& k5 = KeyFromValue5() , const KeyFromValue6& k6 = KeyFromValue6() , const KeyFromValue7& k7 = KeyFromValue7() , const KeyFromValue8& k8 = KeyFromValue8() , const KeyFromValue9& k9 = KeyFromValue9()):
    super( k0 , k1 , k2 , k3 , k4 , k5 , k6 , k7 , k8 , k9)
  {}

  composite_key(const key_extractor_tuple& x):super(x){}

  const key_extractor_tuple& key_extractors()const{return *this;}
  key_extractor_tuple& key_extractors(){return *this;}

  template<typename ChainedPtr>


  typename disable_if<
    is_convertible<const ChainedPtr&,const value_type&>,result_type>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  result_type operator()(const value_type& x)const
  {
    return result_type(*this,x);
  }

  result_type operator()(const reference_wrapper<const value_type>& x)const
  {
    return result_type(*this,x.get());
  }

  result_type operator()(const reference_wrapper<value_type>& x,int=0)const
  {
    return result_type(*this,x.get());
  }
};





template<typename CompositeKey1,typename CompositeKey2>
inline bool operator==(
  const composite_key_result<CompositeKey1>& x,
  const composite_key_result<CompositeKey2>& y)
{
  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
  typedef typename CompositeKey1::value_type value_type1;
  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
  typedef typename CompositeKey2::value_type value_type2;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple1>::value== tuples::length<key_extractor_tuple2>::value) == 0 ? false : true) >)> boost_static_assert_typedef_673

                                                ;

  return detail::equal_ckey_ckey<
    key_extractor_tuple1,value_type1,
    key_extractor_tuple2,value_type2,
    detail::generic_operator_equal_tuple
  >::compare(
    x.composite_key.key_extractors(),x.value,
    y.composite_key.key_extractors(),y.value,
    detail::generic_operator_equal_tuple());
}

template<
  typename CompositeKey,
  typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9
>
inline bool operator==(
  const composite_key_result<CompositeKey>& x,
  const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y)
{
  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
  typedef typename CompositeKey::value_type value_type;
  typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple>::value== tuples::length<key_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_699

                                     ;

  return detail::equal_ckey_cval<
    key_extractor_tuple,value_type,
    key_tuple,detail::generic_operator_equal_tuple
  >::compare(
    x.composite_key.key_extractors(),x.value,
    y,detail::generic_operator_equal_tuple());
}

template
<
  typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,
  typename CompositeKey
>
inline bool operator==(
  const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,
  const composite_key_result<CompositeKey>& y)
{
  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
  typedef typename CompositeKey::value_type value_type;
  typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple>::value== tuples::length<key_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_724

                                     ;

  return detail::equal_ckey_cval<
    key_extractor_tuple,value_type,
    key_tuple,detail::generic_operator_equal_tuple
  >::compare(
    x,y.composite_key.key_extractors(),
    y.value,detail::generic_operator_equal_tuple());
}



template<typename CompositeKey1,typename CompositeKey2>
inline bool operator<(
  const composite_key_result<CompositeKey1>& x,
  const composite_key_result<CompositeKey2>& y)
{
  typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
  typedef typename CompositeKey1::value_type value_type1;
  typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
  typedef typename CompositeKey2::value_type value_type2;

  return detail::compare_ckey_ckey<
   key_extractor_tuple1,value_type1,
   key_extractor_tuple2,value_type2,
   detail::generic_operator_less_tuple
  >::compare(
    x.composite_key.key_extractors(),x.value,
    y.composite_key.key_extractors(),y.value,
    detail::generic_operator_less_tuple());
}

template
<
  typename CompositeKey,
  typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9
>
inline bool operator<(
  const composite_key_result<CompositeKey>& x,
  const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y)
{
  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
  typedef typename CompositeKey::value_type value_type;
  typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

  return detail::compare_ckey_cval<
    key_extractor_tuple,value_type,
    key_tuple,detail::generic_operator_less_tuple
  >::compare(
    x.composite_key.key_extractors(),x.value,
    y,detail::generic_operator_less_tuple());
}

template
<
  typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,
  typename CompositeKey
>
inline bool operator<(
  const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,
  const composite_key_result<CompositeKey>& y)
{
  typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
  typedef typename CompositeKey::value_type value_type;
  typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

  return detail::compare_ckey_cval<
    key_extractor_tuple,value_type,
    key_tuple,detail::generic_operator_less_tuple
  >::compare(
    x,y.composite_key.key_extractors(),
    y.value,detail::generic_operator_less_tuple());
}
# 821 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename CompositeKey1,typename CompositeKey2> inline bool operator!=(const composite_key_result<CompositeKey1>& x,const composite_key_result<CompositeKey2>& y) { return !(x==y); } template<typename CompositeKey1,typename CompositeKey2> inline bool operator>(const composite_key_result<CompositeKey1>& x,const composite_key_result<CompositeKey2>& y) { return y<x; } template<typename CompositeKey1,typename CompositeKey2> inline bool operator>=(const composite_key_result<CompositeKey1>& x,const composite_key_result<CompositeKey2>& y) { return !(x<y); } template<typename CompositeKey1,typename CompositeKey2> inline bool operator<=(const composite_key_result<CompositeKey1>& x,const composite_key_result<CompositeKey2>& y) { return !(y<x); }






template<typename CompositeKey, typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9> inline bool operator!=(const composite_key_result<CompositeKey>& x,const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y) { return !(x==y); } template<typename CompositeKey, typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9> inline bool operator>(const composite_key_result<CompositeKey>& x,const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y) { return y<x; } template<typename CompositeKey, typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9> inline bool operator>=(const composite_key_result<CompositeKey>& x,const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y) { return !(x<y); } template<typename CompositeKey, typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9> inline bool operator<=(const composite_key_result<CompositeKey>& x,const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y) { return !(y<x); }






template< typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,typename CompositeKey> inline bool operator!=(const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,const composite_key_result<CompositeKey>& y) { return !(x==y); } template< typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,typename CompositeKey> inline bool operator>(const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,const composite_key_result<CompositeKey>& y) { return y<x; } template< typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,typename CompositeKey> inline bool operator>=(const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,const composite_key_result<CompositeKey>& y) { return !(x<y); } template< typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,typename CompositeKey> inline bool operator<=(const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,const composite_key_result<CompositeKey>& y) { return !(y<x); }
# 844 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template
<
  typename Pred0 , typename Pred1 =tuples::null_type , typename Pred2 =tuples::null_type , typename Pred3 =tuples::null_type , typename Pred4 =tuples::null_type , typename Pred5 =tuples::null_type , typename Pred6 =tuples::null_type , typename Pred7 =tuples::null_type , typename Pred8 =tuples::null_type , typename Pred9 =tuples::null_type
>
struct composite_key_equal_to:
  private tuple< Pred0 , Pred1 , Pred2 , Pred3 , Pred4 , Pred5 , Pred6 , Pred7 , Pred8 , Pred9>
{
private:
  typedef tuple< Pred0 , Pred1 , Pred2 , Pred3 , Pred4 , Pred5 , Pred6 , Pred7 , Pred8 , Pred9> super;

public:
  typedef super key_eq_tuple;

  composite_key_equal_to(
    const Pred0& k0 = Pred0() , const Pred1& k1 = Pred1() , const Pred2& k2 = Pred2() , const Pred3& k3 = Pred3() , const Pred4& k4 = Pred4() , const Pred5& k5 = Pred5() , const Pred6& k6 = Pred6() , const Pred7& k7 = Pred7() , const Pred8& k8 = Pred8() , const Pred9& k9 = Pred9()):
    super( k0 , k1 , k2 , k3 , k4 , k5 , k6 , k7 , k8 , k9)
  {}

  composite_key_equal_to(const key_eq_tuple& x):super(x){}

  const key_eq_tuple& key_eqs()const{return *this;}
  key_eq_tuple& key_eqs(){return *this;}

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const composite_key_result<CompositeKey1> & x,
    const composite_key_result<CompositeKey2> & y)const
  {
    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
    typedef typename CompositeKey1::value_type value_type1;
    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
    typedef typename CompositeKey2::value_type value_type2;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple1>::value<= tuples::length<key_eq_tuple>::value&& tuples::length<key_extractor_tuple1>::value== tuples::length<key_extractor_tuple2>::value) == 0 ? false : true) >)> boost_static_assert_typedef_881



                                                  ;

    return detail::equal_ckey_ckey<
      key_extractor_tuple1,value_type1,
      key_extractor_tuple2,value_type2,
      key_eq_tuple
    >::compare(
      x.composite_key.key_extractors(),x.value,
      y.composite_key.key_extractors(),y.value,
      key_eqs());
  }

  template
  <
    typename CompositeKey,
    typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9
  >
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y)const
  {
    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
    typedef typename CompositeKey::value_type value_type;
    typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple>::value<= tuples::length<key_eq_tuple>::value&& tuples::length<key_extractor_tuple>::value== tuples::length<key_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_910



                                       ;

    return detail::equal_ckey_cval<
      key_extractor_tuple,value_type,
      key_tuple,key_eq_tuple
    >::compare(x.composite_key.key_extractors(),x.value,y,key_eqs());
  }

  template
  <
    typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,
    typename CompositeKey
  >
  bool operator()(
    const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,
    const composite_key_result<CompositeKey>& y)const
  {
    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
    typedef typename CompositeKey::value_type value_type;
    typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_tuple>::value<= tuples::length<key_eq_tuple>::value&& tuples::length<key_tuple>::value== tuples::length<key_extractor_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_935



                                                 ;

    return detail::equal_ckey_cval<
      key_extractor_tuple,value_type,
      key_tuple,key_eq_tuple
    >::compare(x,y.composite_key.key_extractors(),y.value,key_eqs());
  }
};



template
<
  typename Compare0 , typename Compare1 =tuples::null_type , typename Compare2 =tuples::null_type , typename Compare3 =tuples::null_type , typename Compare4 =tuples::null_type , typename Compare5 =tuples::null_type , typename Compare6 =tuples::null_type , typename Compare7 =tuples::null_type , typename Compare8 =tuples::null_type , typename Compare9 =tuples::null_type
>
struct composite_key_compare:
  private tuple< Compare0 , Compare1 , Compare2 , Compare3 , Compare4 , Compare5 , Compare6 , Compare7 , Compare8 , Compare9>
{
private:
  typedef tuple< Compare0 , Compare1 , Compare2 , Compare3 , Compare4 , Compare5 , Compare6 , Compare7 , Compare8 , Compare9> super;

public:
  typedef super key_comp_tuple;

  composite_key_compare(
    const Compare0& k0 = Compare0() , const Compare1& k1 = Compare1() , const Compare2& k2 = Compare2() , const Compare3& k3 = Compare3() , const Compare4& k4 = Compare4() , const Compare5& k5 = Compare5() , const Compare6& k6 = Compare6() , const Compare7& k7 = Compare7() , const Compare8& k8 = Compare8() , const Compare9& k9 = Compare9()):
    super( k0 , k1 , k2 , k3 , k4 , k5 , k6 , k7 , k8 , k9)
  {}

  composite_key_compare(const key_comp_tuple& x):super(x){}

  const key_comp_tuple& key_comps()const{return *this;}
  key_comp_tuple& key_comps(){return *this;}

  template<typename CompositeKey1,typename CompositeKey2>
  bool operator()(
    const composite_key_result<CompositeKey1> & x,
    const composite_key_result<CompositeKey2> & y)const
  {
    typedef typename CompositeKey1::key_extractor_tuple key_extractor_tuple1;
    typedef typename CompositeKey1::value_type value_type1;
    typedef typename CompositeKey2::key_extractor_tuple key_extractor_tuple2;
    typedef typename CompositeKey2::value_type value_type2;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple1>::value<= tuples::length<key_comp_tuple>::value|| tuples::length<key_extractor_tuple2>::value<= tuples::length<key_comp_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_983



                                            ;

    return detail::compare_ckey_ckey<
      key_extractor_tuple1,value_type1,
      key_extractor_tuple2,value_type2,
      key_comp_tuple
    >::compare(
      x.composite_key.key_extractors(),x.value,
      y.composite_key.key_extractors(),y.value,
      key_comps());
  }


  template<typename CompositeKey,typename Value>
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const Value& y)const
  {
    return operator()(x,boost::make_tuple(boost::cref(y)));
  }


  template
  <
    typename CompositeKey,
    typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9
  >
  bool operator()(
    const composite_key_result<CompositeKey>& x,
    const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& y)const
  {
    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
    typedef typename CompositeKey::value_type value_type;
    typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple>::value<= tuples::length<key_comp_tuple>::value|| tuples::length<key_tuple>::value<= tuples::length<key_comp_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_1022



                                            ;

    return detail::compare_ckey_cval<
      key_extractor_tuple,value_type,
      key_tuple,key_comp_tuple
    >::compare(x.composite_key.key_extractors(),x.value,y,key_comps());
  }


  template<typename Value,typename CompositeKey>
  bool operator()(
    const Value& x,
    const composite_key_result<CompositeKey>& y)const
  {
    return operator()(boost::make_tuple(boost::cref(x)),y);
  }


  template
  <
    typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9,
    typename CompositeKey
  >
  bool operator()(
    const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x,
    const composite_key_result<CompositeKey>& y)const
  {
    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
    typedef typename CompositeKey::value_type value_type;
    typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_tuple>::value<= tuples::length<key_comp_tuple>::value|| tuples::length<key_extractor_tuple>::value<= tuples::length<key_comp_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_1057



                                            ;

    return detail::compare_ckey_cval<
      key_extractor_tuple,value_type,
      key_tuple,key_comp_tuple
    >::compare(x,y.composite_key.key_extractors(),y.value,key_comps());
  }
};



template
<
  typename Hash0 , typename Hash1 =tuples::null_type , typename Hash2 =tuples::null_type , typename Hash3 =tuples::null_type , typename Hash4 =tuples::null_type , typename Hash5 =tuples::null_type , typename Hash6 =tuples::null_type , typename Hash7 =tuples::null_type , typename Hash8 =tuples::null_type , typename Hash9 =tuples::null_type
>
struct composite_key_hash:
  private tuple< Hash0 , Hash1 , Hash2 , Hash3 , Hash4 , Hash5 , Hash6 , Hash7 , Hash8 , Hash9>
{
private:
  typedef tuple< Hash0 , Hash1 , Hash2 , Hash3 , Hash4 , Hash5 , Hash6 , Hash7 , Hash8 , Hash9> super;

public:
  typedef super key_hasher_tuple;

  composite_key_hash(
    const Hash0& k0 = Hash0() , const Hash1& k1 = Hash1() , const Hash2& k2 = Hash2() , const Hash3& k3 = Hash3() , const Hash4& k4 = Hash4() , const Hash5& k5 = Hash5() , const Hash6& k6 = Hash6() , const Hash7& k7 = Hash7() , const Hash8& k8 = Hash8() , const Hash9& k9 = Hash9()):
    super( k0 , k1 , k2 , k3 , k4 , k5 , k6 , k7 , k8 , k9)
  {}

  composite_key_hash(const key_hasher_tuple& x):super(x){}

  const key_hasher_tuple& key_hash_functions()const{return *this;}
  key_hasher_tuple& key_hash_functions(){return *this;}

  template<typename CompositeKey>
  std::size_t operator()(const composite_key_result<CompositeKey> & x)const
  {
    typedef typename CompositeKey::key_extractor_tuple key_extractor_tuple;
    typedef typename CompositeKey::value_type value_type;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_extractor_tuple>::value== tuples::length<key_hasher_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_1099

                                              ;

    return detail::hash_ckey<
      key_extractor_tuple,value_type,
      key_hasher_tuple
    >::hash(x.composite_key.key_extractors(),x.value,key_hash_functions());
  }

  template< typename Value0 , typename Value1 , typename Value2 , typename Value3 , typename Value4 , typename Value5 , typename Value6 , typename Value7 , typename Value8 , typename Value9>
  std::size_t operator()(
    const tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9>& x)const
  {
    typedef tuple< Value0 , Value1 , Value2 , Value3 , Value4 , Value5 , Value6 , Value7 , Value8 , Value9> key_tuple;

    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((tuples::length<key_tuple>::value== tuples::length<key_hasher_tuple>::value) == 0 ? false : true) >)> boost_static_assert_typedef_1115

                                              ;

    return detail::hash_cval<
      key_tuple,key_hasher_tuple
    >::hash(x,key_hash_functions());
  }
};
# 1140 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename CompositeKeyResult>
struct composite_key_result_equal_to:
private
composite_key_equal_to< typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,9 >::type >
{
private:
  typedef composite_key_equal_to< typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_equal_to< typename CompositeKeyResult::composite_key_type,9 >::type > super;

public:
  typedef CompositeKeyResult first_argument_type;
  typedef first_argument_type second_argument_type;
  typedef bool result_type;

  using super::operator();
};
# 1166 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename CompositeKeyResult>
struct composite_key_result_less:
private
composite_key_compare< typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,9 >::type >
{
private:
  typedef composite_key_compare< typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_less< typename CompositeKeyResult::composite_key_type,9 >::type > super;

public:
  typedef CompositeKeyResult first_argument_type;
  typedef first_argument_type second_argument_type;
  typedef bool result_type;

  using super::operator();
};
# 1192 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename CompositeKeyResult>
struct composite_key_result_greater:
private
composite_key_compare< typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,9 >::type >
{
private:
  typedef composite_key_compare< typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_greater< typename CompositeKeyResult::composite_key_type,9 >::type > super;

public:
  typedef CompositeKeyResult first_argument_type;
  typedef first_argument_type second_argument_type;
  typedef bool result_type;

  using super::operator();
};
# 1218 "/opt/sevenflow/boost/include/boost/multi_index/composite_key.hpp"
template<typename CompositeKeyResult>
struct composite_key_result_hash:
private
composite_key_hash< typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,9 >::type >
{
private:
  typedef composite_key_hash< typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,0 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,1 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,2 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,3 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,4 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,5 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,6 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,7 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,8 >::type , typename detail::nth_composite_key_hash< typename CompositeKeyResult::composite_key_type,9 >::type > super;

public:
  typedef CompositeKeyResult argument_type;
  typedef std::size_t result_type;

  using super::operator();
};

}

}






namespace std{

template<typename CompositeKey>
struct equal_to<boost::multi_index::composite_key_result<CompositeKey> >:
  boost::multi_index::composite_key_result_equal_to<
    boost::multi_index::composite_key_result<CompositeKey>
  >
{
};

template<typename CompositeKey>
struct less<boost::multi_index::composite_key_result<CompositeKey> >:
  boost::multi_index::composite_key_result_less<
    boost::multi_index::composite_key_result<CompositeKey>
  >
{
};

template<typename CompositeKey>
struct greater<boost::multi_index::composite_key_result<CompositeKey> >:
  boost::multi_index::composite_key_result_greater<
    boost::multi_index::composite_key_result<CompositeKey>
  >
{
};

}

namespace boost{

template<typename CompositeKey>
struct hash<boost::multi_index::composite_key_result<CompositeKey> >:
  boost::multi_index::composite_key_result_hash<
    boost::multi_index::composite_key_result<CompositeKey>
  >
{
};

}
# 4 "test.cpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
# 1 "/opt/sevenflow/boost/include/boost/foreach_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/foreach_fwd.hpp"
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;

}

}
# 23 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_node.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_node.hpp"
namespace boost{

namespace multi_index{

namespace detail{



template<typename Allocator>
struct hashed_index_node_impl
{
  typedef typename prevent_eti<
    Allocator,
    typename boost::detail::allocator::rebind_to<
      Allocator,hashed_index_node_impl
    >::type
  >::type::pointer pointer;
  typedef typename prevent_eti<
    Allocator,
    typename boost::detail::allocator::rebind_to<
      Allocator,hashed_index_node_impl
    >::type
  >::type::const_pointer const_pointer;

  pointer& next(){return next_;}
  pointer next()const{return next_;}



  static void increment(pointer& x,pointer bbegin,pointer bend)
  {
    std::less_equal<pointer> leq;

    x=x->next();
    if(leq(bbegin,x)&&leq(x,bend)){
      do{
        ++x;
      }while(x->next()==x);
      x=x->next();
    }
  }

  static void link(pointer x,pointer pos)
  {
    x->next()=pos->next();
    pos->next()=x;
  };

  static void unlink(pointer x)
  {
    pointer y=x->next();
    while(y->next()!=x){y=y->next();}
    y->next()=x->next();
  }

  static pointer prev(pointer x)
  {
    pointer y=x->next();
    while(y->next()!=x){y=y->next();}
    return y;
  }

  static void unlink_next(pointer x)
  {
    x->next()=x->next()->next();
  }

private:
  pointer next_;
};

template<typename Super>
struct hashed_index_node_trampoline:
  prevent_eti<
    Super,
    hashed_index_node_impl<
      typename boost::detail::allocator::rebind_to<
        typename Super::allocator_type,
        char
      >::type
    >
  >::type
{
  typedef typename prevent_eti<
    Super,
    hashed_index_node_impl<
      typename boost::detail::allocator::rebind_to<
        typename Super::allocator_type,
        char
      >::type
    >
  >::type impl_type;
};

template<typename Super>
struct hashed_index_node:Super,hashed_index_node_trampoline<Super>
{
private:
  typedef hashed_index_node_trampoline<Super> trampoline;

public:
  typedef typename trampoline::impl_type impl_type;
  typedef typename trampoline::pointer impl_pointer;
  typedef typename trampoline::const_pointer const_impl_pointer;

  impl_pointer impl()
  {
    return static_cast<impl_pointer>(
      static_cast<impl_type*>(static_cast<trampoline*>(this)));
  }

  const_impl_pointer impl()const
  {
    return static_cast<const_impl_pointer>(
      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
  }

  static hashed_index_node* from_impl(impl_pointer x)
  {
    return static_cast<hashed_index_node*>(
      static_cast<trampoline*>(&*x));
  }

  static const hashed_index_node* from_impl(const_impl_pointer x)
  {
    return static_cast<const hashed_index_node*>(
      static_cast<const trampoline*>(&*x));
  }

  static void increment(
    hashed_index_node*& x,impl_pointer bbegin,impl_pointer bend)
  {
    impl_pointer xi=x->impl();
    trampoline::increment(xi,bbegin,bend);
    x=from_impl(xi);
  }
};

}

}

}
# 20 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 23 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp" 2
# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 24 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp" 2







namespace boost{

namespace multi_index{

namespace detail{



class bucket_array_base:private noncopyable
{
protected:
  inline static std::size_t next_prime(std::size_t n)
  {
    static const std::size_t prime_list[]={
      53ul, 97ul, 193ul, 389ul, 769ul,
      1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
      49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
      1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
      50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
      1610612741ul, 3221225473ul,
# 62 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp"
      6442450939ul, 12884901893ul, 25769803751ul, 51539607551ul,
      103079215111ul, 206158430209ul, 412316860441ul, 824633720831ul,
      1649267441651ul, 3298534883309ul, 6597069766657ul, 13194139533299ul,
      26388279066623ul, 52776558133303ul, 105553116266489ul, 211106232532969ul,
      422212465066001ul, 844424930131963ul, 1688849860263953ul,
      3377699720527861ul, 6755399441055731ul, 13510798882111483ul,
      27021597764222939ul, 54043195528445957ul, 108086391056891903ul,
      216172782113783843ul, 432345564227567621ul, 864691128455135207ul,
      1729382256910270481ul, 3458764513820540933ul, 6917529027641081903ul,
      13835058055282163729ul, 18446744073709551557ul


    };
    static const std::size_t prime_list_size=
      sizeof(prime_list)/sizeof(prime_list[0]);

    std::size_t const *bound=
      std::lower_bound(prime_list,prime_list+prime_list_size,n);
    if(bound==prime_list+prime_list_size)bound--;
    return *bound;
  }
};

template<typename Allocator>
class bucket_array:public bucket_array_base
{
  typedef typename prevent_eti<
    Allocator,
    hashed_index_node_impl<
      typename boost::detail::allocator::rebind_to<
        Allocator,
        char
      >::type
    >
  >::type node_impl_type;

public:
  typedef typename node_impl_type::pointer pointer;

  bucket_array(const Allocator& al,pointer end_,std::size_t size):
    size_(bucket_array_base::next_prime(size)),
    spc(al,size_+1)
  {
    clear();
    end()->next()=end_;
    end_->next()=end();
  }

  std::size_t size()const
  {
    return size_;
  }

  std::size_t position(std::size_t hash)const
  {
    return hash%size_;
  }

  pointer begin()const{return buckets();}
  pointer end()const{return buckets()+size_;}
  pointer at(std::size_t n)const{return buckets()+n;}

  std::size_t first_nonempty(std::size_t n)const
  {
    for(;;++n){
      pointer x=at(n);
      if(x->next()!=x)return n;
    }
  }

  void clear()
  {
    for(pointer x=begin(),y=end();x!=y;++x)x->next()=x;
  }

  void swap(bucket_array& x)
  {
    std::swap(size_,x.size_);
    spc.swap(x.spc);
  }

private:
  std::size_t size_;
  auto_space<node_impl_type,Allocator> spc;

  pointer buckets()const
  {
    return spc.data();
  }


  friend class boost::serialization::access;






  template<class Archive>
  void serialize(Archive&,const unsigned int)
  {
  }

};

template<typename Allocator>
void swap(bucket_array<Allocator>& x,bucket_array<Allocator>& y)
{
  x.swap(y);
}

}

}
# 187 "/opt/sevenflow/boost/include/boost/multi_index/detail/bucket_array.hpp"
namespace multi_index{
namespace detail{


template<class Archive,typename Allocator>
inline void load_construct_data(
  Archive&,boost::multi_index::detail::bucket_array<Allocator>*,
  const unsigned int)
{
  throw_exception(
    archive::archive_exception(archive::archive_exception::other_exception));
}




}
}




}
# 29 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_iterator.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_iterator.hpp"
namespace boost{

namespace multi_index{

namespace detail{




template<typename Node,typename BucketArray>
class hashed_index_iterator:
  public forward_iterator_helper<
    hashed_index_iterator<Node,BucketArray>,
    typename Node::value_type,
    std::ptrdiff_t,
    const typename Node::value_type*,
    const typename Node::value_type&>
{
public:
  hashed_index_iterator(){}
  hashed_index_iterator(Node* node_,BucketArray* buckets_):
    node(node_),buckets(buckets_)
  {}

  const typename Node::value_type& operator*()const
  {
    return node->value();
  }

  hashed_index_iterator& operator++()
  {
    Node::increment(node,buckets->begin(),buckets->end());
    return *this;
  }






  template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }

  typedef typename Node::base_type node_base_type;

  template<class Archive>
  void save(Archive& ar,const unsigned int)const
  {
    node_base_type* bnode=node;
    ar<<serialization::make_nvp("pointer",bnode);
    ar<<serialization::make_nvp("pointer",buckets);
  }

  template<class Archive>
  void load(Archive& ar,const unsigned int)
  {
    node_base_type* bnode;
    ar>>serialization::make_nvp("pointer",bnode);
    node=static_cast<Node*>(bnode);
    ar>>serialization::make_nvp("pointer",buckets);
  }




  typedef Node node_type;

  Node* get_node()const{return node;}

private:
  Node* node;
  BucketArray* buckets;
};

template<typename Node,typename BucketArray>
bool operator==(
  const hashed_index_iterator<Node,BucketArray>& x,
  const hashed_index_iterator<Node,BucketArray>& y)
{
  return x.get_node()==y.get_node();
}

}

}

}
# 30 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/modify_key_adaptor.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/multi_index/detail/modify_key_adaptor.hpp"
namespace boost{

namespace multi_index{

namespace detail{






template<typename Fun,typename Value,typename KeyFromValue>
struct modify_key_adaptor
{

  modify_key_adaptor(Fun f_,KeyFromValue kfv_):f(f_),kfv(kfv_){}

  void operator()(Value& x)
  {
    f(kfv(x));
  }

private:
  Fun f;
  KeyFromValue kfv;
};

}

}

}
# 32 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/safe_ctr_proxy.hpp" 1
# 33 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index_fwd.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index_fwd.hpp"
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_args.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_args.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash.hpp" 1





# 1 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/detail/float_functions.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/functional/hash/detail/float_functions.hpp"
namespace boost {
    namespace hash_detail {



        struct not_found {



            inline operator float() const { return 0; }
            inline operator long double() const { return 0; }
        };



        template <typename T> struct is;
        template <> struct is<float> { char x[10]; };
        template <> struct is<double> { char x[20]; };
        template <> struct is<long double> { char x[30]; };
        template <> struct is<boost::hash_detail::not_found> { char x[40]; };



        template <typename T> is<T> float_type(T);





        template <typename Float> struct call_ldexp
        {
            typedef double float_type;

            inline double operator()(double a, int b) const
            {
                using namespace std;
                return ldexp(a, b);
            }
        };





        template <typename Float> struct call_frexp
        {
            typedef double float_type;

            inline double operator()(double a, int* b) const
            {
                using namespace std;
                return frexp(a, b);
            }
        };
    }
}
# 87 "/opt/sevenflow/boost/include/boost/functional/hash/detail/float_functions.hpp"
namespace boost_hash_detect_float_functions {
    template <class Float> boost::hash_detail::not_found ldexp(Float, int);
    template <class Float> boost::hash_detail::not_found frexp(Float, int*);
}
# 188 "/opt/sevenflow/boost/include/boost/functional/hash/detail/float_functions.hpp"
namespace boost_hash_detect_float_functions { template <class Float> boost::hash_detail::not_found ldexpf(Float, int); } namespace boost { namespace hash_detail { namespace ldexpf_detect { using namespace std; using namespace boost_hash_detect_float_functions; struct check { static float x; static int y; static const bool cpp = sizeof(float_type(ldexp(x,y))) == sizeof(is<float>); static const bool c99 = sizeof(float_type(ldexpf(x,y))) == sizeof(is<float>); }; } template <bool x> struct call_c99_ldexpf : boost::hash_detail::call_ldexp<double> {}; template <> struct call_c99_ldexpf<true> { typedef float float_type; template <typename T> inline float operator()(float a, T b) const { using namespace std; return ldexpf(a, b); } }; template <bool x> struct call_cpp_ldexpf : call_c99_ldexpf< ::boost::hash_detail::ldexpf_detect::check::c99 > {}; template <> struct call_cpp_ldexpf<true> { typedef float float_type; template <typename T> inline float operator()(float a, T b) const { using namespace std; return ldexp(a, b); } }; template <> struct call_ldexp<float> : call_cpp_ldexpf< ::boost::hash_detail::ldexpf_detect::check::cpp > {}; } }





namespace boost_hash_detect_float_functions { template <class Float> boost::hash_detail::not_found ldexpl(Float, int); } namespace boost { namespace hash_detail { namespace ldexpl_detect { using namespace std; using namespace boost_hash_detect_float_functions; struct check { static long double x; static int y; static const bool cpp = sizeof(float_type(ldexp(x,y))) == sizeof(is<long double>); static const bool c99 = sizeof(float_type(ldexpl(x,y))) == sizeof(is<long double>); }; } template <bool x> struct call_c99_ldexpl : boost::hash_detail::call_ldexp<double> {}; template <> struct call_c99_ldexpl<true> { typedef long double float_type; template <typename T> inline long double operator()(long double a, T b) const { using namespace std; return ldexpl(a, b); } }; template <bool x> struct call_cpp_ldexpl : call_c99_ldexpl< ::boost::hash_detail::ldexpl_detect::check::c99 > {}; template <> struct call_cpp_ldexpl<true> { typedef long double float_type; template <typename T> inline long double operator()(long double a, T b) const { using namespace std; return ldexp(a, b); } }; template <> struct call_ldexp<long double> : call_cpp_ldexpl< ::boost::hash_detail::ldexpl_detect::check::cpp > {}; } }





namespace boost_hash_detect_float_functions { template <class Float> boost::hash_detail::not_found frexpf(Float, int*); } namespace boost { namespace hash_detail { namespace frexpf_detect { using namespace std; using namespace boost_hash_detect_float_functions; struct check { static float x; static int* y; static const bool cpp = sizeof(float_type(frexp(x,y))) == sizeof(is<float>); static const bool c99 = sizeof(float_type(frexpf(x,y))) == sizeof(is<float>); }; } template <bool x> struct call_c99_frexpf : boost::hash_detail::call_frexp<double> {}; template <> struct call_c99_frexpf<true> { typedef float float_type; template <typename T> inline float operator()(float a, T b) const { using namespace std; return frexpf(a, b); } }; template <bool x> struct call_cpp_frexpf : call_c99_frexpf< ::boost::hash_detail::frexpf_detect::check::c99 > {}; template <> struct call_cpp_frexpf<true> { typedef float float_type; template <typename T> inline float operator()(float a, T b) const { using namespace std; return frexp(a, b); } }; template <> struct call_frexp<float> : call_cpp_frexpf< ::boost::hash_detail::frexpf_detect::check::cpp > {}; } }





namespace boost_hash_detect_float_functions { template <class Float> boost::hash_detail::not_found frexpl(Float, int*); } namespace boost { namespace hash_detail { namespace frexpl_detect { using namespace std; using namespace boost_hash_detect_float_functions; struct check { static long double x; static int* y; static const bool cpp = sizeof(float_type(frexp(x,y))) == sizeof(is<long double>); static const bool c99 = sizeof(float_type(frexpl(x,y))) == sizeof(is<long double>); }; } template <bool x> struct call_c99_frexpl : boost::hash_detail::call_frexp<double> {}; template <> struct call_c99_frexpl<true> { typedef long double float_type; template <typename T> inline long double operator()(long double a, T b) const { using namespace std; return frexpl(a, b); } }; template <bool x> struct call_cpp_frexpl : call_c99_frexpl< ::boost::hash_detail::frexpl_detect::check::c99 > {}; template <> struct call_cpp_frexpl<true> { typedef long double float_type; template <typename T> inline long double operator()(long double a, T b) const { using namespace std; return frexp(a, b); } }; template <> struct call_frexp<long double> : call_cpp_frexpl< ::boost::hash_detail::frexpl_detect::check::cpp > {}; } }






namespace boost
{
    namespace hash_detail
    {
        template <typename Float1, typename Float2>
        struct select_hash_type_impl {
            typedef double type;
        };

        template <>
        struct select_hash_type_impl<float, float> {
            typedef float type;
        };

        template <>
        struct select_hash_type_impl<long double, long double> {
            typedef long double type;
        };







        template <typename Float>
        struct select_hash_type : select_hash_type_impl<
                typename call_ldexp<Float>::float_type,
                typename call_frexp<Float>::float_type
            > {};
    }
}
# 15 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/detail/limits.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/functional/hash/detail/limits.hpp"
namespace boost
{
    namespace hash_detail
    {
        template <class T>
        struct limits : std::numeric_limits<T> {};
# 58 "/opt/sevenflow/boost/include/boost/functional/hash/detail/limits.hpp"
    }
}
# 16 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/integer/static_log2.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/integer/static_log2.hpp"
# 1 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp"
# 1 "/usr/include/c++/4.8.2/climits" 1 3
# 39 "/usr/include/c++/4.8.2/climits" 3
       
# 40 "/usr/include/c++/4.8.2/climits" 3

# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/limits.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/climits" 2 3
# 13 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 14 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp" 2



# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp" 2


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 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp"
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 "/opt/sevenflow/boost/include/boost/integer_fwd.hpp"
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 "/opt/sevenflow/boost/include/boost/integer/static_log2.hpp" 2

namespace boost {

 namespace detail {

     namespace static_log2_impl {
# 44 "/opt/sevenflow/boost/include/boost/integer/static_log2.hpp"
     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 "/opt/sevenflow/boost/include/boost/integer/static_log2.hpp"
     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> { };

}
# 17 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/cstdint.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/assert.hpp" 1
# 50 "/opt/sevenflow/boost/include/boost/assert.hpp"
# 1 "/usr/include/assert.h" 1 3 4
# 65 "/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 "/opt/sevenflow/boost/include/boost/assert.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float_generic.hpp" 1
# 27 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float_generic.hpp"
namespace boost
{
    namespace hash_detail
    {
        inline void hash_float_combine(std::size_t& seed, std::size_t value)
        {
            seed ^= value + (seed<<6) + (seed>>2);
        }

        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));
        }
    }
}
# 31 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp" 2
# 57 "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp"
namespace boost
{
    namespace hash_detail
    {
        template <class T>
        inline std::size_t float_hash_value(T v)
        {
            using namespace std;
            switch (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);
            default:
                ((0) ? static_cast<void> (0) : __assert_fail ("0", "/opt/sevenflow/boost/include/boost/functional/hash/detail/hash_float.hpp", 76, __PRETTY_FUNCTION__));
                return 0;
            }
        }
    }
}
# 16 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
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 <> 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 {};


        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 <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 <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);
    }
# 215 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
    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);
        }
    }
# 276 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
    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);
    }
# 385 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
    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); } };
# 424 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
    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);






        }
    };
# 483 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
}
# 495 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp"
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/functional/hash/detail/container_fwd_0x.hpp" 1
# 9 "/opt/sevenflow/boost/include/boost/functional/hash/detail/container_fwd_0x.hpp"
# 1 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp" 1
# 91 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp"
# 1 "/usr/include/c++/4.8.2/deque" 1 3
# 58 "/usr/include/c++/4.8.2/deque" 3
       
# 59 "/usr/include/c++/4.8.2/deque" 3





# 1 "/usr/include/c++/4.8.2/bits/stl_deque.h" 1 3
# 66 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 88 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_deque.h" 3
      deque&
      operator=(const deque& __x);
# 977 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_deque.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1301 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/stl_deque.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1518 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_deque.h" 3
      iterator
      erase(iterator __position);
# 1583 "/usr/include/c++/4.8.2/bits/stl_deque.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1595 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_deque.h" 3
      void
      _M_fill_initialize(const value_type& __value);
# 1695 "/usr/include/c++/4.8.2/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.2/bits/stl_deque.h" 3
      void _M_pop_back_aux();

      void _M_pop_front_aux();
# 1778 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/deque" 2 3

# 1 "/usr/include/c++/4.8.2/bits/deque.tcc" 1 3
# 59 "/usr/include/c++/4.8.2/bits/deque.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 90 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/deque.tcc" 3

}
# 67 "/usr/include/c++/4.8.2/deque" 2 3
# 92 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/list" 1 3
# 58 "/usr/include/c++/4.8.2/list" 3
       
# 59 "/usr/include/c++/4.8.2/list" 3




# 1 "/usr/include/c++/4.8.2/bits/stl_list.h" 1 3
# 64 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
  namespace __detail
  {
 
# 77 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_list.h" 3
      list&
      operator=(const list& __x);
# 701 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/stl_list.h" 3
      void
      push_front(const value_type& __x)
      { this->_M_insert(begin(), __x); }
# 1000 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
      void
      pop_front()
      { this->_M_erase(begin()); }
# 1014 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
      void
      push_back(const value_type& __x)
      { this->_M_insert(end(), __x); }
# 1040 "/usr/include/c++/4.8.2/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.2/bits/stl_list.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1122 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_list.h" 3
      iterator
      erase(iterator __position);
# 1192 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/bits/stl_list.h" 3
      void
      remove(const _Tp& __value);
# 1361 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
      template<typename _Predicate>
        void
        remove_if(_Predicate);
# 1375 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
      void
      unique();
# 1390 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
      template<typename _BinaryPredicate>
        void
        unique(_BinaryPredicate);
# 1411 "/usr/include/c++/4.8.2/bits/stl_list.h" 3
      void
      merge(list& __x);
# 1438 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/list" 2 3
# 1 "/usr/include/c++/4.8.2/bits/list.tcc" 1 3
# 59 "/usr/include/c++/4.8.2/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.2/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.2/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.2/list" 2 3
# 93 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/vector" 1 3
# 58 "/usr/include/c++/4.8.2/vector" 3
       
# 59 "/usr/include/c++/4.8.2/vector" 3





# 1 "/usr/include/c++/4.8.2/bits/stl_vector.h" 1 3
# 66 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 478 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 769 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
      reference
      operator[](size_type __n)
      { return *(this->_M_impl._M_start + __n); }
# 784 "/usr/include/c++/4.8.2/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.2/bits/stl_vector.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 827 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/bits/stl_vector.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 1022 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_vector.h" 3
      iterator
      erase(iterator __position);
# 1095 "/usr/include/c++/4.8.2/bits/stl_vector.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 1107 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/bits/stl_vector.h" 3
      void
      _M_insert_aux(iterator __position, const value_type& __x);
# 1335 "/usr/include/c++/4.8.2/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.2/bits/stl_vector.h" 3
    };
# 1401 "/usr/include/c++/4.8.2/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.2/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.2/vector" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_bvector.h" 1 3
# 63 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/stl_bvector.h" 3
    void
    assign(size_type __n, const bool& __x)
    { _M_fill_assign(__n, __x); }
# 672 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/vector" 2 3



# 1 "/usr/include/c++/4.8.2/bits/vector.tcc" 1 3
# 59 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bits/vector.tcc" 3

}
# 70 "/usr/include/c++/4.8.2/vector" 2 3
# 94 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp" 2

# 1 "/usr/include/c++/4.8.2/set" 1 3
# 58 "/usr/include/c++/4.8.2/set" 3
       
# 59 "/usr/include/c++/4.8.2/set" 3


# 1 "/usr/include/c++/4.8.2/bits/stl_set.h" 1 3
# 64 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 88 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/stl_set.h" 3
      set(const set& __x)
      : _M_t(__x._M_t) { }
# 232 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
      set&
      operator=(const set& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 280 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_set.h" 3
      void
      swap(set& __x)
      { _M_t.swap(__x._M_t); }
# 459 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/stl_set.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 580 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 618 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 629 "/usr/include/c++/4.8.2/bits/stl_set.h" 3
      void
      clear()
      { _M_t.clear(); }
# 643 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/set" 2 3
# 1 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 1 3
# 64 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

# 90 "/usr/include/c++/4.8.2/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.2/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.2/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.2/bits/stl_multiset.h" 3
      multiset(const multiset& __x)
      : _M_t(__x._M_t) { }
# 228 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
      multiset&
      operator=(const multiset& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }
# 277 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_multiset.h" 3
      void
      swap(multiset& __x)
      { _M_t.swap(__x._M_t); }
# 453 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }
# 483 "/usr/include/c++/4.8.2/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.2/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.2/bits/stl_multiset.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 566 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 604 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }
# 615 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
      void
      clear()
      { _M_t.clear(); }
# 626 "/usr/include/c++/4.8.2/bits/stl_multiset.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 644 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/set" 2 3
# 96 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp" 2
# 1 "/usr/include/c++/4.8.2/bitset" 1 3
# 45 "/usr/include/c++/4.8.2/bitset" 3
       
# 46 "/usr/include/c++/4.8.2/bitset" 3
# 60 "/usr/include/c++/4.8.2/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.2/bitset" 3
      _Base_bitset(unsigned long __val)
      : _M_w()
      { _M_w[0] = __val; }


      static size_t
      _S_whichword(size_t __pos)
      { return __pos / (8 * 8); }

      static size_t
      _S_whichbyte(size_t __pos)
      { return (__pos % (8 * 8)) / 8; }

      static size_t
      _S_whichbit(size_t __pos)
      { return __pos % (8 * 8); }

      static _WordT
      _S_maskbit(size_t __pos)
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      _WordT&
      _M_getword(size_t __pos)
      { return _M_w[_S_whichword(__pos)]; }

      _WordT
      _M_getword(size_t __pos) const
      { return _M_w[_S_whichword(__pos)]; }







      _WordT&
      _M_hiword()
      { return _M_w[_Nw - 1]; }

      _WordT
      _M_hiword() const
      { return _M_w[_Nw - 1]; }

      void
      _M_do_and(const _Base_bitset<_Nw>& __x)
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] &= __x._M_w[__i];
      }

      void
      _M_do_or(const _Base_bitset<_Nw>& __x)
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] |= __x._M_w[__i];
      }

      void
      _M_do_xor(const _Base_bitset<_Nw>& __x)
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] ^= __x._M_w[__i];
      }

      void
      _M_do_left_shift(size_t __shift) ;

      void
      _M_do_right_shift(size_t __shift) ;

      void
      _M_do_flip()
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] = ~_M_w[__i];
      }

      void
      _M_do_set()
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] = ~static_cast<_WordT>(0);
      }

      void
      _M_do_reset()
      { __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT)); }

      bool
      _M_is_equal(const _Base_bitset<_Nw>& __x) const
      {
 for (size_t __i = 0; __i < _Nw; ++__i)
   if (_M_w[__i] != __x._M_w[__i])
     return false;
 return true;
      }

      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 * 8)
         - _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 * 8);
   const size_t __offset = __shift % (8 * 8);

   if (__offset == 0)
     for (size_t __n = _Nw - 1; __n >= __wshift; --__n)
       _M_w[__n] = _M_w[__n - __wshift];
   else
     {
       const size_t __sub_offset = ((8 * 8)
        - __offset);
       for (size_t __n = _Nw - 1; __n > __wshift; --__n)
  _M_w[__n] = ((_M_w[__n - __wshift] << __offset)
        | (_M_w[__n - __wshift - 1] >> __sub_offset));
       _M_w[__wshift] = _M_w[0] << __offset;
     }

   std::fill(_M_w + 0, _M_w + __wshift, static_cast<_WordT>(0));
 }
    }

  template<size_t _Nw>
    void
    _Base_bitset<_Nw>::_M_do_right_shift(size_t __shift)
    {
      if (__builtin_expect(__shift != 0, 1))
 {
   const size_t __wshift = __shift / (8 * 8);
   const size_t __offset = __shift % (8 * 8);
   const size_t __limit = _Nw - __wshift - 1;

   if (__offset == 0)
     for (size_t __n = 0; __n <= __limit; ++__n)
       _M_w[__n] = _M_w[__n + __wshift];
   else
     {
       const size_t __sub_offset = ((8 * 8)
        - __offset);
       for (size_t __n = 0; __n < __limit; ++__n)
  _M_w[__n] = ((_M_w[__n + __wshift] >> __offset)
        | (_M_w[__n + __wshift + 1] << __sub_offset));
       _M_w[__limit] = _M_w[_Nw-1] >> __offset;
     }

   std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
 }
    }

  template<size_t _Nw>
    unsigned long
    _Base_bitset<_Nw>::_M_do_to_ulong() const
    {
      for (size_t __i = 1; __i < _Nw; ++__i)
 if (_M_w[__i])
   __throw_overflow_error(("_Base_bitset::_M_do_to_ulong"));
      return _M_w[0];
    }
# 314 "/usr/include/c++/4.8.2/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 * 8)
      + __builtin_ctzl(__thisword));
 }

      return __not_found;
    }

  template<size_t _Nw>
    size_t
    _Base_bitset<_Nw>::
    _M_do_find_next(size_t __prev, size_t __not_found) const
    {

      ++__prev;


      if (__prev >= _Nw * (8 * 8))
 return __not_found;


      size_t __i = _S_whichword(__prev);
      _WordT __thisword = _M_w[__i];


      __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);

      if (__thisword != static_cast<_WordT>(0))
 return (__i * (8 * 8)
  + __builtin_ctzl(__thisword));


      __i++;
      for (; __i < _Nw; __i++)
 {
   __thisword = _M_w[__i];
   if (__thisword != static_cast<_WordT>(0))
     return (__i * (8 * 8)
      + __builtin_ctzl(__thisword));
 }

      return __not_found;
    }






  template<>
    struct _Base_bitset<1>
    {
      typedef unsigned long _WordT;
      _WordT _M_w;

      _Base_bitset()
      : _M_w(0)
      { }




      _Base_bitset(unsigned long __val)

      : _M_w(__val)
      { }

      static size_t
      _S_whichword(size_t __pos)
      { return __pos / (8 * 8); }

      static size_t
      _S_whichbyte(size_t __pos)
      { return (__pos % (8 * 8)) / 8; }

      static size_t
      _S_whichbit(size_t __pos)
      { return __pos % (8 * 8); }

      static _WordT
      _S_maskbit(size_t __pos)
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }

      _WordT&
      _M_getword(size_t)
      { return _M_w; }

      _WordT
      _M_getword(size_t) const
      { return _M_w; }







      _WordT&
      _M_hiword()
      { return _M_w; }

      _WordT
      _M_hiword() const
      { return _M_w; }

      void
      _M_do_and(const _Base_bitset<1>& __x)
      { _M_w &= __x._M_w; }

      void
      _M_do_or(const _Base_bitset<1>& __x)
      { _M_w |= __x._M_w; }

      void
      _M_do_xor(const _Base_bitset<1>& __x)
      { _M_w ^= __x._M_w; }

      void
      _M_do_left_shift(size_t __shift)
      { _M_w <<= __shift; }

      void
      _M_do_right_shift(size_t __shift)
      { _M_w >>= __shift; }

      void
      _M_do_flip()
      { _M_w = ~_M_w; }

      void
      _M_do_set()
      { _M_w = ~static_cast<_WordT>(0); }

      void
      _M_do_reset()
      { _M_w = 0; }

      bool
      _M_is_equal(const _Base_bitset<1>& __x) const
      { return _M_w == __x._M_w; }

      template<size_t _Nb>
        bool
        _M_are_all() const
        { return _M_w == (~static_cast<_WordT>(0)
     >> ((8 * 8) - _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 * 8)))
   return __not_found;

 _WordT __x = _M_w >> __prev;
 if (__x != 0)
   return __builtin_ctzl(__x) + __prev;
 else
   return __not_found;
      }
    };






  template<>
    struct _Base_bitset<0>
    {
      typedef unsigned long _WordT;

      _Base_bitset()
      { }




      _Base_bitset(unsigned long)

      { }

      static size_t
      _S_whichword(size_t __pos)
      { return __pos / (8 * 8); }

      static size_t
      _S_whichbyte(size_t __pos)
      { return (__pos % (8 * 8)) / 8; }

      static size_t
      _S_whichbit(size_t __pos)
      { return __pos % (8 * 8); }

      static _WordT
      _S_maskbit(size_t __pos)
      { return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
# 556 "/usr/include/c++/4.8.2/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.2/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.2/bitset" 3
  template<size_t _Nb>
    class bitset
    : private _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))>
    {
    private:
      typedef _Base_bitset<((_Nb) / (8 * 8) + ((_Nb) % (8 * 8) == 0 ? 0 : 1))> _Base;
      typedef unsigned long _WordT;

      void
      _M_do_sanitize()
      {
 typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
 __sanitize_type::_S_do_sanitize(this->_M_hiword());
      }





    public:
# 779 "/usr/include/c++/4.8.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/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.2/bitset" 3
      unsigned long
      to_ulong() const
      { return this->_M_do_to_ulong(); }
# 1177 "/usr/include/c++/4.8.2/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.2/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.2/bitset" 3
      size_t
      _Find_first() const
      { return this->_M_do_find_first(_Nb); }
# 1364 "/usr/include/c++/4.8.2/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.2/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.2/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 "/opt/sevenflow/boost/include/boost/detail/container_fwd.hpp" 2
# 10 "/opt/sevenflow/boost/include/boost/functional/hash/detail/container_fwd_0x.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp" 2
# 35 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp"
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;
    }
# 251 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp"
    template <class T> struct hash
        : std::unary_function<T, std::size_t>
    {

        std::size_t operator()(T const& val) const
        {
            return hash_value(val);
        }






    };
# 365 "/opt/sevenflow/boost/include/boost/functional/hash/extensions.hpp"
}
# 496 "/opt/sevenflow/boost/include/boost/functional/hash/hash.hpp" 2
# 7 "/opt/sevenflow/boost/include/boost/functional/hash.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_args.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_args.hpp"
namespace boost{

namespace multi_index{

namespace detail{
# 49 "/opt/sevenflow/boost/include/boost/multi_index/detail/hash_index_args.hpp"
template<typename KeyFromValue>
struct index_args_default_hash
{
  typedef ::boost::hash<typename KeyFromValue::result_type> type;
};

template<typename KeyFromValue>
struct index_args_default_pred
{
  typedef std::equal_to<typename KeyFromValue::result_type> type;
};

template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
struct hashed_index_args
{
  typedef is_tag<Arg1> full_form;

  typedef typename mpl::if_<
    full_form,
    Arg1,
    tag< > >::type tag_list_type;
  typedef typename mpl::if_<
    full_form,
    Arg2,
    Arg1>::type key_from_value_type;
  typedef typename mpl::if_<
    full_form,
    Arg3,
    Arg2>::type supplied_hash_type;
  typedef typename mpl::eval_if<
    mpl::is_na<supplied_hash_type>,
    index_args_default_hash<key_from_value_type>,
    mpl::identity<supplied_hash_type>
  >::type hash_type;
  typedef typename mpl::if_<
    full_form,
    Arg4,
    Arg3>::type supplied_pred_type;
  typedef typename mpl::eval_if<
    mpl::is_na<supplied_pred_type>,
    index_args_default_pred<key_from_value_type>,
    mpl::identity<supplied_pred_type>
  >::type pred_type;

  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_tag<tag_list_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_93;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!mpl::is_na<key_from_value_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_94;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!mpl::is_na<hash_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_95;
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!mpl::is_na<pred_type>::value) == 0 ? false : true) >)> boost_static_assert_typedef_96;
};

}

}

}
# 17 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index_fwd.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{

template<
  typename KeyFromValue,typename Hash,typename Pred,
  typename SuperMeta,typename TagList,typename Category
>
class hashed_index;

template<
  typename KeyFromValue,typename Hash,typename Pred,
  typename SuperMeta,typename TagList,typename Category
>
void swap(
  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y);

}



template<
  typename Arg1,typename Arg2=mpl::na,
  typename Arg3=mpl::na,typename Arg4=mpl::na
>
struct hashed_unique;

template<
  typename Arg1,typename Arg2=mpl::na,
  typename Arg3=mpl::na,typename Arg4=mpl::na
>
struct hashed_non_unique;

}

}
# 36 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2

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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 38 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp" 2
# 54 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
namespace boost{

namespace multi_index{

namespace detail{
# 67 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
struct hashed_unique_tag{};
struct hashed_non_unique_tag{};

template<
  typename KeyFromValue,typename Hash,typename Pred,
  typename SuperMeta,typename TagList,typename Category
>
class hashed_index:
  protected SuperMeta::type
# 90 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
{
# 101 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
  typedef typename SuperMeta::type super;

protected:
  typedef hashed_index_node<
    typename super::node_type> node_type;

private:
  typedef typename node_type::impl_type node_impl_type;
  typedef typename node_impl_type::pointer node_impl_pointer;
  typedef bucket_array<
    typename super::final_allocator_type> bucket_array_type;

public:


  typedef typename KeyFromValue::result_type key_type;
  typedef typename node_type::value_type value_type;
  typedef KeyFromValue key_from_value;
  typedef Hash hasher;
  typedef Pred key_equal;
  typedef tuple<std::size_t,
    key_from_value,hasher,key_equal> ctor_args;
  typedef typename super::final_allocator_type allocator_type;
  typedef typename allocator_type::pointer pointer;
  typedef typename allocator_type::const_pointer const_pointer;
  typedef typename allocator_type::reference reference;
  typedef typename allocator_type::const_reference const_reference;
  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;
# 146 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
  typedef hashed_index_iterator<
    node_type,bucket_array_type> iterator;


  typedef iterator const_iterator;

  typedef iterator local_iterator;
  typedef const_iterator const_local_iterator;
  typedef TagList tag_list;

protected:
  typedef typename super::final_node_type final_node_type;
  typedef tuples::cons<
    ctor_args,
    typename super::ctor_args_list> ctor_args_list;
  typedef typename mpl::push_front<
    typename super::index_type_list,
    hashed_index>::type index_type_list;
  typedef typename mpl::push_front<
    typename super::iterator_type_list,
    iterator>::type iterator_type_list;
  typedef typename mpl::push_front<
    typename super::const_iterator_type_list,
    const_iterator>::type const_iterator_type_list;
  typedef typename super::copy_map_type copy_map_type;


  typedef typename super::index_saver_type index_saver_type;
  typedef typename super::index_loader_type index_loader_type;


private:
# 190 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
  typedef typename call_traits<value_type>::param_type value_param_type;
  typedef typename call_traits<
    key_type>::param_type key_param_type;

public:






  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& operator=(
    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
  {
    this->final()=x.final();
    return *this;
  }

  allocator_type get_allocator()const
  {
    return this->final().get_allocator();
  }



  bool empty()const{return this->final_empty_();}
  size_type size()const{return this->final_size_();}
  size_type max_size()const{return this->final_max_size_();}



  iterator begin()
  {
    return make_iterator(
      node_type::from_impl(buckets.at(first_bucket)->next()));
  }

  const_iterator begin()const
  {
    return make_iterator(
      node_type::from_impl(buckets.at(first_bucket)->next()));
  }

  iterator end(){return make_iterator(header());}
  const_iterator end()const{return make_iterator(header());}

  const_iterator cbegin()const{return begin();}
  const_iterator cend()const{return end();}

  iterator iterator_to(const value_type& x)
  {
    return make_iterator(node_from_value<node_type>(&x));
  }

  const_iterator iterator_to(const value_type& x)const
  {
    return make_iterator(node_from_value<node_type>(&x));
  }



  std::pair<iterator,bool> insert(value_param_type x)
  {
    ;
    std::pair<final_node_type*,bool> p=this->final_insert_(x);
    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
  }

  iterator insert(iterator position,value_param_type x)
  {
    ((void)0);;
    ((void)0);;
    ;
    std::pair<final_node_type*,bool> p=this->final_insert_(
      x,static_cast<final_node_type*>(position.get_node()));
    return make_iterator(p.first);
  }

  template<typename InputIterator>
  void insert(InputIterator first,InputIterator last)
  {
    ;
    iterator hint=end();
    for(;first!=last;++first)hint=insert(hint,*first);
  }

  iterator erase(iterator position)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
    return position;
  }

  size_type erase(key_param_type k)
  {
    ;

    size_type s=0;
    std::size_t buc=buckets.position(hash(k));
    node_impl_pointer x=buckets.at(buc);
    node_impl_pointer y=x->next();
    while(y!=x){
      if(eq(k,key(node_type::from_impl(y)->value()))){
        bool b;
        do{
          node_impl_pointer z=y->next();
          b=z!=x&&eq(
            key(node_type::from_impl(y)->value()),
            key(node_type::from_impl(z)->value()));
          this->final_erase_(
            static_cast<final_node_type*>(node_type::from_impl(y)));
          y=z;
          ++s;
        }while(b);
        break;
      }
      y=y->next();
    }
    return s;
  }

  iterator erase(iterator first,iterator last)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    while(first!=last){
      first=erase(first);
    }
    return first;
  }

  bool replace(iterator position,value_param_type x)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    return this->final_replace_(
      x,static_cast<final_node_type*>(position.get_node()));
  }

  template<typename Modifier>
  bool modify(iterator position,Modifier mod)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
# 355 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
    return this->final_modify_(
      mod,static_cast<final_node_type*>(position.get_node()));
  }

  template<typename Modifier,typename Rollback>
  bool modify(iterator position,Modifier mod,Rollback back)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
# 376 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
    return this->final_modify_(
      mod,back,static_cast<final_node_type*>(position.get_node()));
  }

  template<typename Modifier>
  bool modify_key(iterator position,Modifier mod)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    return modify(
      position,modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key));
  }

  template<typename Modifier,typename Rollback>
  bool modify_key(iterator position,Modifier mod,Rollback back)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    return modify(
      position,
      modify_key_adaptor<Modifier,value_type,KeyFromValue>(mod,key),
      modify_key_adaptor<Rollback,value_type,KeyFromValue>(back,key));
  }

  void clear()
  {
    ;
    this->final_clear_();
  }

  void swap(hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
  {
    ;
    this->final_swap_(x.final());
  }



  key_from_value key_extractor()const{return key;}
  hasher hash_function()const{return hash;}
  key_equal key_eq()const{return eq;}







  template<typename CompatibleKey>
  iterator find(const CompatibleKey& k)const
  {
    return find(k,hash,eq);
  }

  template<
    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
  >
  iterator find(
    const CompatibleKey& k,
    const CompatibleHash& hash,const CompatiblePred& eq)const
  {
    std::size_t buc=buckets.position(hash(k));
    node_impl_pointer x=buckets.at(buc);
    node_impl_pointer y=x->next();
    while(y!=x){
      if(eq(k,key(node_type::from_impl(y)->value()))){
        return make_iterator(node_type::from_impl(y));
      }
      y=y->next();
    }
    return end();
  }

  template<typename CompatibleKey>
  size_type count(const CompatibleKey& k)const
  {
    return count(k,hash,eq);
  }

  template<
    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
  >
  size_type count(
    const CompatibleKey& k,
    const CompatibleHash& hash,const CompatiblePred& eq)const
  {
    size_type res=0;
    std::size_t buc=buckets.position(hash(k));
    node_impl_pointer x=buckets.at(buc);
    node_impl_pointer y=x->next();
    while(y!=x){
      if(eq(k,key(node_type::from_impl(y)->value()))){
        do{
          ++res;
          y=y->next();
        }while(y!=x&&eq(k,key(node_type::from_impl(y)->value())));
        break;
      }
      y=y->next();
    }
    return res;
  }

  template<typename CompatibleKey>
  std::pair<iterator,iterator> equal_range(const CompatibleKey& k)const
  {
    return equal_range(k,hash,eq);
  }

  template<
    typename CompatibleKey,typename CompatibleHash,typename CompatiblePred
  >
  std::pair<iterator,iterator> equal_range(
    const CompatibleKey& k,
    const CompatibleHash& hash,const CompatiblePred& eq)const
  {
    std::size_t buc=buckets.position(hash(k));
    node_impl_pointer x=buckets.at(buc);
    node_impl_pointer y=x->next();
    while(y!=x){
      if(eq(k,key(node_type::from_impl(y)->value()))){
        node_impl_pointer y0=y;
        do{
          y=y->next();
        }while(y!=x&&eq(k,key(node_type::from_impl(y)->value())));
        if(y==x){
          do{
            ++y;
          }while(y==y->next());
          y=y->next();
        }
        return std::pair<iterator,iterator>(
          make_iterator(node_type::from_impl(y0)),
          make_iterator(node_type::from_impl(y)));
      }
      y=y->next();
    }
    return std::pair<iterator,iterator>(end(),end());
  }



  size_type bucket_count()const{return buckets.size();}
  size_type max_bucket_count()const{return static_cast<size_type>(-1);}

  size_type bucket_size(size_type n)const
  {
    size_type res=0;
    node_impl_pointer x=buckets.at(n);
    node_impl_pointer y=x->next();
    while(y!=x){
      ++res;
      y=y->next();
    }
    return res;
  }

  size_type bucket(key_param_type k)const
  {
    return buckets.position(hash(k));
  }

  local_iterator begin(size_type n)
  {
    return const_cast<const hashed_index*>(this)->begin(n);
  }

  const_local_iterator begin(size_type n)const
  {
    node_impl_pointer x=buckets.at(n);
    node_impl_pointer y=x->next();
    if(y==x)return end();
    return make_iterator(node_type::from_impl(y));
  }

  local_iterator end(size_type n)
  {
    return const_cast<const hashed_index*>(this)->end(n);
  }

  const_local_iterator end(size_type n)const
  {
    node_impl_pointer x=buckets.at(n);
    if(x==x->next())return end();
    do{
      ++x;
    }while(x==x->next());
    return make_iterator(node_type::from_impl(x->next()));
  }

  const_local_iterator cbegin(size_type n)const{return begin(n);}
  const_local_iterator cend(size_type n)const{return end(n);}

  local_iterator local_iterator_to(const value_type& x)
  {
    return make_iterator(node_from_value<node_type>(&x));
  }

  const_local_iterator local_iterator_to(const value_type& x)const
  {
    return make_iterator(node_from_value<node_type>(&x));
  }



  float load_factor()const{return static_cast<float>(size())/bucket_count();}
  float max_load_factor()const{return mlf;}
  void max_load_factor(float z){mlf=z;calculate_max_load();}

  void rehash(size_type n)
  {
    ;
    if(size()<max_load&&n<=bucket_count())return;

    size_type bc =(std::numeric_limits<size_type>::max)();
    float fbc=static_cast<float>(1+size()/mlf);
    if(bc>fbc){
      bc=static_cast<size_type>(fbc);
      if(bc<n)bc=n;
    }
    unchecked_rehash(bc);
  }

protected:
  hashed_index(const ctor_args_list& args_list,const allocator_type& al):
    super(args_list.get_tail(),al),
    key(tuples::get<1>(args_list.get_head())),
    hash(tuples::get<2>(args_list.get_head())),
    eq(tuples::get<3>(args_list.get_head())),
    buckets(al,header()->impl(),tuples::get<0>(args_list.get_head())),
    mlf(1.0f),
    first_bucket(buckets.size())
  {
    calculate_max_load();
  }

  hashed_index(
    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x):
    super(x),





    key(x.key),
    hash(x.hash),
    eq(x.eq),
    buckets(x.get_allocator(),header()->impl(),x.buckets.size()),
    mlf(x.mlf),
    max_load(x.max_load),
    first_bucket(x.first_bucket)
  {



  }

  ~hashed_index()
  {

  }
# 656 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
  iterator make_iterator(node_type* node)
  {
    return iterator(node,&buckets);
  }

  const_iterator make_iterator(node_type* node)const
  {
    return const_iterator(node,&const_cast<bucket_array_type&>(buckets));
  }


  void copy_(
    const hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
    const copy_map_type& map)
  {
    for(node_impl_pointer begin_org=x.buckets.begin(),
                          begin_cpy=buckets.begin(),
                          end_org=x.buckets.end();
        begin_org!=end_org;++begin_org,++begin_cpy){

      node_impl_pointer next_org=begin_org->next();
      node_impl_pointer cpy=begin_cpy;
      while(next_org!=begin_org){
        cpy->next()=
          static_cast<node_type*>(
            map.find(
              static_cast<final_node_type*>(
                node_type::from_impl(next_org))))->impl();
        next_org=next_org->next();
        cpy=cpy->next();
      }
      cpy->next()=begin_cpy;
    }

    super::copy_(x,map);
  }

  node_type* insert_(value_param_type v,node_type* x)
  {
    reserve(size()+1);

    std::size_t buc=find_bucket(v);
    node_impl_pointer pos=buckets.at(buc);
    if(!link_point(v,pos,Category()))return node_type::from_impl(pos);

    node_type* res=static_cast<node_type*>(super::insert_(v,x));
    if(res==x){
      link(x,pos);
      if(first_bucket>buc)first_bucket=buc;
    }
    return res;
  }

  node_type* insert_(value_param_type v,node_type* position,node_type* x)
  {
    reserve(size()+1);

    std::size_t buc=find_bucket(v);
    node_impl_pointer pos=buckets.at(buc);
    if(!link_point(v,pos,Category()))return node_type::from_impl(pos);

    node_type* res=static_cast<node_type*>(super::insert_(v,position,x));
    if(res==x){
      link(x,pos);
      if(first_bucket>buc)first_bucket=buc;
    }
    return res;
  }

  void erase_(node_type* x)
  {
    unlink(x);
    first_bucket=buckets.first_nonempty(first_bucket);
    super::erase_(x);




  }

  void delete_all_nodes_()
  {
    for(node_impl_pointer x=buckets.begin(),x_end=buckets.end();
        x!=x_end;++x){
      node_impl_pointer y=x->next();
      while(y!=x){
        node_impl_pointer z=y->next();
        this->final_delete_node_(
          static_cast<final_node_type*>(node_type::from_impl(y)));
        y=z;
      }
    }
  }

  void clear_()
  {
    super::clear_();
    buckets.clear();
    first_bucket=buckets.size();




  }

  void swap_(
    hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x)
  {
    std::swap(key,x.key);
    std::swap(hash,x.hash);
    std::swap(eq,x.eq);
    buckets.swap(x.buckets);
    std::swap(mlf,x.mlf);
    std::swap(max_load,x.max_load);
    std::swap(first_bucket,x.first_bucket);





    super::swap_(x);
  }

  bool replace_(value_param_type v,node_type* x)
  {
    if(eq(key(v),key(x->value()))){
      return super::replace_(v,x);
    }

    node_impl_pointer y=prev(x);
    unlink_next(y);

    { try{
      std::size_t buc=find_bucket(v);
      node_impl_pointer pos=buckets.at(buc);
      if(link_point(v,pos,Category())&&super::replace_(v,x)){
        link(x,pos);
        if(first_bucket>buc){
          first_bucket=buc;
        }
        else if(first_bucket<buc){
          first_bucket=buckets.first_nonempty(first_bucket);
        }
        return true;
      }
      link(x,y);
      return false;
    }
    catch(...){
      link(x,y);
      throw;;
    }
    }
  }

  bool modify_(node_type* x)
  {
    std::size_t buc;
    bool b;
    { try{
      buc=find_bucket(x->value());
      b=in_place(x->impl(),key(x->value()),buc,Category());
    }
    catch(...){
      erase_(x);
      throw;;
    }
    }
    if(!b){
      unlink(x);
      { try{
        node_impl_pointer pos=buckets.at(buc);
        if(!link_point(x->value(),pos,Category())){
          first_bucket=buckets.first_nonempty(first_bucket);
          super::erase_(x);




          return false;
        }
        link(x,pos);
        if(first_bucket>buc){
          first_bucket=buc;
        }
        else if(first_bucket<buc){
          first_bucket=buckets.first_nonempty(first_bucket);
        }
      }
      catch(...){
        first_bucket=buckets.first_nonempty(first_bucket);
        super::erase_(x);





        throw;;
      }
      }
    }

    { try{
      if(!super::modify_(x)){
        unlink(x);
        first_bucket=buckets.first_nonempty(first_bucket);



        return false;
      }
      else return true;
    }
    catch(...){
      unlink(x);
      first_bucket=buckets.first_nonempty(first_bucket);





      throw;;
    }
    }
  }

  bool modify_rollback_(node_type* x)
  {
    std::size_t buc=find_bucket(x->value());
    if(in_place(x->impl(),key(x->value()),buc,Category())){
      return super::modify_rollback_(x);
    }

    node_impl_pointer y=prev(x);
    unlink_next(y);

    { try{
      node_impl_pointer pos=buckets.at(buc);
      if(link_point(x->value(),pos,Category())&&super::modify_rollback_(x)){
        link(x,pos);
        if(first_bucket>buc){
          first_bucket=buc;
        }
        else if(first_bucket<buc){
          first_bucket=buckets.first_nonempty(first_bucket);
        }
        return true;
      }
      link(x,y);
      return false;
    }
    catch(...){
      link(x,y);
      throw;;
    }
    }
  }




  template<typename Archive>
  void save_(
    Archive& ar,const unsigned int version,const index_saver_type& sm)const
  {
    ar<<serialization::make_nvp("position",buckets);
    super::save_(ar,version,sm);
  }

  template<typename Archive>
  void load_(Archive& ar,const unsigned int version,const index_loader_type& lm)
  {
    ar>>serialization::make_nvp("position",buckets);
    super::load_(ar,version,lm);
  }
# 971 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
private:
  node_type* header()const{return this->final_header();}

  std::size_t find_bucket(value_param_type v)const
  {
    return bucket(key(v));
  }

  bool link_point(
    value_param_type v,node_impl_pointer& pos,hashed_unique_tag)
  {
    node_impl_pointer x=pos->next();
    while(x!=pos){
      if(eq(key(v),key(node_type::from_impl(x)->value()))){
        pos=x;
        return false;
      }
      x=x->next();
    }
    return true;
  }

  bool link_point(
    value_param_type v,node_impl_pointer& pos,hashed_non_unique_tag)
  {
    node_impl_pointer prev=pos;
    node_impl_pointer x=pos->next();
    while(x!=pos){
      if(eq(key(v),key(node_type::from_impl(x)->value()))){
        pos=prev;
        return true;
      }
      prev=x;
      x=x->next();
    }
    return true;
  }

  static void link(node_type* x,node_impl_pointer pos)
  {
    node_impl_type::link(x->impl(),pos);
  };

  static void link(node_impl_pointer x,node_impl_pointer pos)
  {
    node_impl_type::link(x,pos);
  };

  static void unlink(node_type* x)
  {
    node_impl_type::unlink(x->impl());
  };

  static node_impl_pointer prev(node_type* x)
  {
    return node_impl_type::prev(x->impl());
  }

  static node_impl_pointer prev_from(node_type* x,node_impl_pointer y)
  {
    return node_impl_type::prev_from(x->impl(),y);
  }

  static void unlink_next(node_impl_pointer x)
  {
    node_impl_type::unlink_next(x);
  }

  void calculate_max_load()
  {
    float fml=static_cast<float>(mlf*bucket_count());
    max_load=(std::numeric_limits<size_type>::max)();
    if(max_load>fml)max_load=static_cast<size_type>(fml);
  }

  void reserve(size_type n)
  {
    if(n>max_load){
      size_type bc =(std::numeric_limits<size_type>::max)();
      float fbc=static_cast<float>(1+n/mlf);
      if(bc>fbc)bc =static_cast<size_type>(fbc);
      unchecked_rehash(bc);
    }
  }

  void unchecked_rehash(size_type n)
  {
    bucket_array_type buckets1(get_allocator(),header()->impl(),n);
    auto_space<std::size_t,allocator_type> hashes(get_allocator(),size());

    std::size_t i=0;
    node_impl_pointer x=buckets.begin();
    node_impl_pointer x_end=buckets.end();
    for(;x!=x_end;++x){
      node_impl_pointer y=x->next();
      while(y!=x){
        hashes.data()[i++]=hash(key(node_type::from_impl(y)->value()));
        y=y->next();
      }
    }

    i=0;
    x=buckets.begin();
    for(;x!=x_end;++x){
      node_impl_pointer y=x->next();
      while(y!=x){
        node_impl_pointer z=y->next();
        std::size_t buc1=buckets1.position(hashes.data()[i++]);
        node_impl_pointer x1=buckets1.at(buc1);
        link(y,x1);
        y=z;
      }
    }

    buckets.swap(buckets1);
    calculate_max_load();
    first_bucket=buckets.first_nonempty(0);
  }

  bool in_place(
    node_impl_pointer x,key_param_type k,std::size_t buc,
    hashed_unique_tag)const
  {
    std::less_equal<node_impl_pointer> leq;
    node_impl_pointer bbegin=buckets.begin();
    node_impl_pointer bend=buckets.end();
    node_impl_pointer pbuc=x->next();

    while(!leq(bbegin,pbuc)||!leq(pbuc,bend))pbuc=pbuc->next();
    if(buc!=static_cast<std::size_t>(pbuc-bbegin))return false;

    node_impl_pointer y=x;
    while(y->next()!=x){
      y=y->next();
      if(y==pbuc)continue;
      if(eq(k,key(node_type::from_impl(y)->value())))return false;
    }
    return true;
  }

  bool in_place(
    node_impl_pointer x,key_param_type k,std::size_t buc,
    hashed_non_unique_tag)const
  {
    std::less_equal<node_impl_pointer> leq;
    node_impl_pointer bbegin=buckets.begin();
    node_impl_pointer bend=buckets.end();
    node_impl_pointer pbuc=x->next();

    while(!leq(bbegin,pbuc)||!leq(pbuc,bend))pbuc=pbuc->next();
    if(buc!=static_cast<std::size_t>(pbuc-bbegin))return false;

    node_impl_pointer y=x->next();
    if(y!=pbuc){
      if(eq(k,key(node_type::from_impl(y)->value()))){

        return true;
      }
      else{
        y=y->next();
        while(y!=pbuc){
          if(eq(k,key(node_type::from_impl(y)->value())))return false;
          y=y->next();
        }
      }
    }
    while(y->next()!=x){
      y=y->next();
      if(eq(k,key(node_type::from_impl(y)->value()))){
        while(y->next()!=x){
          y=y->next();
          if(!eq(k,key(node_type::from_impl(y)->value())))return false;
        }

        return true;
      }
    }
    return true;
  }
# 1160 "/opt/sevenflow/boost/include/boost/multi_index/hashed_index.hpp"
  key_from_value key;
  hasher hash;
  key_equal eq;
  bucket_array_type buckets;
  float mlf;
  size_type max_load;
  std::size_t first_bucket;





};



template<
  typename KeyFromValue,typename Hash,typename Pred,
  typename SuperMeta,typename TagList,typename Category
>
void swap(
  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& x,
  hashed_index<KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>& y)
{
  x.swap(y);
}

}



template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
struct hashed_unique
{
  typedef typename detail::hashed_index_args<
    Arg1,Arg2,Arg3,Arg4> index_args;
  typedef typename index_args::tag_list_type::type tag_list_type;
  typedef typename index_args::key_from_value_type key_from_value_type;
  typedef typename index_args::hash_type hash_type;
  typedef typename index_args::pred_type pred_type;

  template<typename Super>
  struct node_class
  {
    typedef detail::hashed_index_node<Super> type;
  };

  template<typename SuperMeta>
  struct index_class
  {
    typedef detail::hashed_index<
      key_from_value_type,hash_type,pred_type,
      SuperMeta,tag_list_type,detail::hashed_unique_tag> type;
  };
};

template<typename Arg1,typename Arg2,typename Arg3,typename Arg4>
struct hashed_non_unique
{
  typedef typename detail::hashed_index_args<
    Arg1,Arg2,Arg3,Arg4> index_args;
  typedef typename index_args::tag_list_type::type tag_list_type;
  typedef typename index_args::key_from_value_type key_from_value_type;
  typedef typename index_args::hash_type hash_type;
  typedef typename index_args::pred_type pred_type;

  template<typename Super>
  struct node_class
  {
    typedef detail::hashed_index_node<Super> type;
  };

  template<typename SuperMeta>
  struct index_class
  {
    typedef detail::hashed_index<
      key_from_value_type,hash_type,pred_type,
      SuperMeta,tag_list_type,detail::hashed_non_unique_tag> type;
  };
};

}

}



template<
  typename KeyFromValue,typename Hash,typename Pred,
  typename SuperMeta,typename TagList,typename Category
>
inline boost::mpl::true_* boost_foreach_is_noncopyable(
  boost::multi_index::detail::hashed_index<
    KeyFromValue,Hash,Pred,SuperMeta,TagList,Category>*&,
  boost::foreach::tag)
{
  return 0;
}
# 5 "test.cpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/reverse_iterator.hpp" 1
# 11 "/opt/sevenflow/boost/include/boost/iterator/reverse_iterator.hpp"
# 1 "/opt/sevenflow/boost/include/boost/utility.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/utility.hpp"
# 1 "/opt/sevenflow/boost/include/boost/utility/binary.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/utility/binary.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/control/deduce_d.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/control/deduce_d.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/control/deduce_d.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/utility/binary.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/preprocessor/seq/cat.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/seq/cat.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/seq/fold_left.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/seq/fold_left.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/detail/auto_rec.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/seq/fold_left.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/seq/seq.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/preprocessor/seq/seq.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/seq/elem.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/seq/seq.hpp" 2
# 21 "/opt/sevenflow/boost/include/boost/preprocessor/seq/fold_left.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/seq/size.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/preprocessor/seq/fold_left.hpp" 2
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/seq/cat.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/utility/binary.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/seq/transform.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/utility/binary.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/mod.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/mod.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 1
# 19 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/detail/div_base.hpp"
# 1 "/opt/sevenflow/boost/include/boost/preprocessor/comparison/less_equal.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 2
# 18 "/opt/sevenflow/boost/include/boost/preprocessor/arithmetic/mod.hpp" 2
# 32 "/opt/sevenflow/boost/include/boost/utility/binary.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/utility.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/utility/identity_type.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/utility.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/next_prior.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/next_prior.hpp"
namespace boost {
# 29 "/opt/sevenflow/boost/include/boost/next_prior.hpp"
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;
}

}
# 19 "/opt/sevenflow/boost/include/boost/utility.hpp" 2
# 12 "/opt/sevenflow/boost/include/boost/iterator/reverse_iterator.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/detail/iterator.hpp" 1
# 77 "/opt/sevenflow/boost/include/boost/detail/iterator.hpp"
namespace boost { namespace detail {


template <class Iterator>
struct iterator_traits
    : std::iterator_traits<Iterator>
{};
using std::distance;

}}
# 13 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp" 1
# 11 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_def.hpp" 1
# 12 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp" 2





# 1 "/opt/sevenflow/boost/include/boost/mpl/placeholders.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp" 2






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 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp"
  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 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp"
}





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 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp"
}

# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_undef.hpp" 1
# 187 "/opt/sevenflow/boost/include/boost/iterator/iterator_categories.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 1
# 11 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/interoperable.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/iterator/interoperable.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_def.hpp" 1
# 16 "/opt/sevenflow/boost/include/boost/iterator/interoperable.hpp" 2

namespace boost
{
# 34 "/opt/sevenflow/boost/include/boost/iterator/interoperable.hpp"
  template <typename A, typename B>
  struct is_interoperable



    : mpl::or_<
          is_convertible< A, B >
        , is_convertible< B, A > >

  {
  };

}

# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_undef.hpp" 1
# 49 "/opt/sevenflow/boost/include/boost/iterator/interoperable.hpp" 2
# 12 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/iterator/iterator_traits.hpp" 1
# 11 "/opt/sevenflow/boost/include/boost/iterator/iterator_traits.hpp"
namespace boost {
# 27 "/opt/sevenflow/boost/include/boost/iterator/iterator_traits.hpp"
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 "/opt/sevenflow/boost/include/boost/iterator/iterator_traits.hpp"
}
# 13 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 1
# 23 "/opt/sevenflow/boost/include/boost/iterator/detail/facade_iterator_category.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_def.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/detail/indirect_traits.hpp" 1
# 33 "/opt/sevenflow/boost/include/boost/detail/indirect_traits.hpp"
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 "/opt/sevenflow/boost/include/boost/detail/indirect_traits.hpp"
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 "/opt/sevenflow/boost/include/boost/detail/indirect_traits.hpp"
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 "/opt/sevenflow/boost/include/boost/detail/indirect_traits.hpp"
}

using namespace indirect_traits;

}}
# 27 "/opt/sevenflow/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2







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 "/opt/sevenflow/boost/include/boost/iterator/detail/facade_iterator_category.hpp"
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 "/opt/sevenflow/boost/include/boost/iterator/detail/config_undef.hpp" 1
# 199 "/opt/sevenflow/boost/include/boost/iterator/detail/facade_iterator_category.hpp" 2
# 15 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/enable_if.hpp" 1
# 13 "/opt/sevenflow/boost/include/boost/iterator/detail/enable_if.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_def.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/iterator/detail/enable_if.hpp" 2







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 "/opt/sevenflow/boost/include/boost/iterator/detail/enable_if.hpp"
      };
    };


    template <class Cond,
              class Return>
    struct enable_if

      : enabled<(Cond::value)>::template base<Return>



    {



    };

  }

}

# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_undef.hpp" 1
# 85 "/opt/sevenflow/boost/include/boost/iterator/detail/enable_if.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2
# 34 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mpl/apply.hpp" 1
# 35 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2


# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_def.hpp" 1
# 38 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2

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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
      : ::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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
    };







    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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
            typename remove_reference<Reference>::type
            const volatile*
          , Value const volatile*
        >
    {};
# 270 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
    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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
    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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >

        {};

    };
  }
# 469 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
  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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
      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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
  };


  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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
  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 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp"
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 "/opt/sevenflow/boost/include/boost/iterator/detail/config_undef.hpp" 1
# 873 "/opt/sevenflow/boost/include/boost/iterator/iterator_facade.hpp" 2
# 16 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp" 2
# 30 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp"
# 1 "/opt/sevenflow/boost/include/boost/iterator/detail/config_def.hpp" 1
# 31 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp" 2



namespace boost
{



  struct use_default;





  template<class To>
  struct is_convertible<use_default,To>
    : mpl::false_ {};


  namespace detail
  {
# 60 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp"
    struct enable_type;
  }
# 142 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp"
  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 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp"
  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 "/opt/sevenflow/boost/include/boost/iterator/detail/config_undef.hpp" 1
# 364 "/opt/sevenflow/boost/include/boost/iterator/iterator_adaptor.hpp" 2
# 13 "/opt/sevenflow/boost/include/boost/iterator/reverse_iterator.hpp" 2

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

}
# 23 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/bidir_node_iterator.hpp" 1
# 24 "/opt/sevenflow/boost/include/boost/multi_index/detail/bidir_node_iterator.hpp"
namespace boost{

namespace multi_index{

namespace detail{





template<typename Node>
class bidir_node_iterator:
  public bidirectional_iterator_helper<
    bidir_node_iterator<Node>,
    typename Node::value_type,
    std::ptrdiff_t,
    const typename Node::value_type*,
    const typename Node::value_type&>
{
public:
  bidir_node_iterator(){}
  explicit bidir_node_iterator(Node* node_):node(node_){}

  const typename Node::value_type& operator*()const
  {
    return node->value();
  }

  bidir_node_iterator& operator++()
  {
    Node::increment(node);
    return *this;
  }

  bidir_node_iterator& operator--()
  {
    Node::decrement(node);
    return *this;
  }






  template<class Archive> void serialize( Archive &ar, const unsigned int file_version ){ boost::serialization::split_member(ar, *this, file_version); }

  typedef typename Node::base_type node_base_type;

  template<class Archive>
  void save(Archive& ar,const unsigned int)const
  {
    node_base_type* bnode=node;
    ar<<serialization::make_nvp("pointer",bnode);
  }

  template<class Archive>
  void load(Archive& ar,const unsigned int)
  {
    node_base_type* bnode;
    ar>>serialization::make_nvp("pointer",bnode);
    node=static_cast<Node*>(bnode);
  }




  typedef Node node_type;

  Node* get_node()const{return node;}

private:
  Node* node;
};

template<typename Node>
bool operator==(
  const bidir_node_iterator<Node>& x,
  const bidir_node_iterator<Node>& y)
{
  return x.get_node()==y.get_node();
}

}

}

}
# 28 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/seq_index_node.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/multi_index/detail/seq_index_node.hpp"
namespace boost{

namespace multi_index{

namespace detail{



template<typename Allocator>
struct sequenced_index_node_impl
{
  typedef typename prevent_eti<
    Allocator,
    typename boost::detail::allocator::rebind_to<
      Allocator,sequenced_index_node_impl
    >::type
  >::type::pointer pointer;
  typedef typename prevent_eti<
    Allocator,
    typename boost::detail::allocator::rebind_to<
      Allocator,sequenced_index_node_impl
    >::type
  >::type::const_pointer const_pointer;

  pointer& prior(){return prior_;}
  pointer prior()const{return prior_;}
  pointer& next(){return next_;}
  pointer next()const{return next_;}



  static void increment(pointer& x){x=x->next();}
  static void decrement(pointer& x){x=x->prior();}



  static void link(pointer x,pointer header)
  {
    x->prior()=header->prior();
    x->next()=header;
    x->prior()->next()=x->next()->prior()=x;
  };

  static void unlink(pointer x)
  {
    x->prior()->next()=x->next();
    x->next()->prior()=x->prior();
  }

  static void relink(pointer position,pointer x)
  {
    unlink(x);
    x->prior()=position->prior();
    x->next()=position;
    x->prior()->next()=x->next()->prior()=x;
  }

  static void relink(pointer position,pointer x,pointer y)
  {


    if(x!=y){
      pointer z=y->prior();
      x->prior()->next()=y;
      y->prior()=x->prior();
      x->prior()=position->prior();
      z->next()=position;
      x->prior()->next()=x;
      z->next()->prior()=z;
    }
  }

  static void reverse(pointer header)
  {
    pointer x=header;
    do{
      pointer y=x->next();
      std::swap(x->prior(),x->next());
      x=y;
    }while(x!=header);
  }

  static void swap(pointer x,pointer y)
  {





    if(x->next()!=x){
      if(y->next()!=y){
        std::swap(x->next(),y->next());
        std::swap(x->prior(),y->prior());
        x->next()->prior()=x->prior()->next()=x;
        y->next()->prior()=y->prior()->next()=y;
      }
      else{
        y->next()=x->next();
        y->prior()=x->prior();
        x->next()=x->prior()=x;
        y->next()->prior()=y->prior()->next()=y;
      }
    }
    else if(y->next()!=y){
      x->next()=y->next();
      x->prior()=y->prior();
      y->next()=y->prior()=y;
      x->next()->prior()=x->prior()->next()=x;
    }
  }

private:
  pointer prior_;
  pointer next_;
};

template<typename Super>
struct sequenced_index_node_trampoline:
  prevent_eti<
    Super,
    sequenced_index_node_impl<
      typename boost::detail::allocator::rebind_to<
        typename Super::allocator_type,
        char
      >::type
    >
  >::type
{
  typedef typename prevent_eti<
    Super,
    sequenced_index_node_impl<
      typename boost::detail::allocator::rebind_to<
        typename Super::allocator_type,
        char
      >::type
    >
  >::type impl_type;
};

template<typename Super>
struct sequenced_index_node:Super,sequenced_index_node_trampoline<Super>
{
private:
  typedef sequenced_index_node_trampoline<Super> trampoline;

public:
  typedef typename trampoline::impl_type impl_type;
  typedef typename trampoline::pointer impl_pointer;
  typedef typename trampoline::const_pointer const_impl_pointer;

  impl_pointer& prior(){return trampoline::prior();}
  impl_pointer prior()const{return trampoline::prior();}
  impl_pointer& next(){return trampoline::next();}
  impl_pointer next()const{return trampoline::next();}

  impl_pointer impl()
  {
    return static_cast<impl_pointer>(
      static_cast<impl_type*>(static_cast<trampoline*>(this)));
  }

  const_impl_pointer impl()const
  {
    return static_cast<const_impl_pointer>(
      static_cast<const impl_type*>(static_cast<const trampoline*>(this)));
  }

  static sequenced_index_node* from_impl(impl_pointer x)
  {
    return static_cast<sequenced_index_node*>(
      static_cast<trampoline*>(&*x));
  }

  static const sequenced_index_node* from_impl(const_impl_pointer x)
  {
    return static_cast<const sequenced_index_node*>(
      static_cast<const trampoline*>(&*x));
  }



  static void increment(sequenced_index_node*& x)
  {
    impl_pointer xi=x->impl();
    trampoline::increment(xi);
    x=from_impl(xi);
  }

  static void decrement(sequenced_index_node*& x)
  {
    impl_pointer xi=x->impl();
    trampoline::decrement(xi);
    x=from_impl(xi);
  }
};

}

}

}
# 33 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/detail/seq_index_ops.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/multi_index/detail/seq_index_ops.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 23 "/opt/sevenflow/boost/include/boost/multi_index/detail/seq_index_ops.hpp" 2

namespace boost{

namespace multi_index{

namespace detail{





template <typename SequencedIndex,typename Predicate>
void sequenced_index_remove(SequencedIndex& x,Predicate pred)
{
  typedef typename SequencedIndex::iterator iterator;
  iterator first=x.begin(),last=x.end();
  while(first!=last){
    if(pred(*first))x.erase(first++);
    else ++first;
  }
}

template <typename SequencedIndex,class BinaryPredicate>
void sequenced_index_unique(SequencedIndex& x,BinaryPredicate binary_pred)
{
  typedef typename SequencedIndex::iterator iterator;
  iterator first=x.begin();
  iterator last=x.end();
  if(first!=last){
    for(iterator middle=first;++middle!=last;middle=first){
      if(binary_pred(*middle,*first))x.erase(middle);
      else first=middle;
    }
  }
}

template <typename SequencedIndex,typename Compare>
void sequenced_index_merge(SequencedIndex& x,SequencedIndex& y,Compare comp)
{
  typedef typename SequencedIndex::iterator iterator;
  if(&x!=&y){
    iterator first0=x.begin(),last0=x.end();
    iterator first1=y.begin(),last1=y.end();
    while(first0!=last0&&first1!=last1){
      if(comp(*first1,*first0))x.splice(first0,y,first1++);
      else ++first0;
    }
    x.splice(last0,y,first1,last1);
  }
}





template<typename Node,typename Compare>
void sequenced_index_collate(
  typename Node::impl_type* x,
  typename Node::impl_type* y,
  Compare comp
  )
{
  typedef typename Node::impl_type impl_type;
  typedef typename Node::impl_pointer impl_pointer;

  impl_pointer first0=x->next();
  impl_pointer last0=x;
  impl_pointer first1=y->next();
  impl_pointer last1=y;
  while(first0!=last0&&first1!=last1){
    if(comp(
        Node::from_impl(first1)->value(),Node::from_impl(first0)->value())){
      impl_pointer tmp=first1->next();
      impl_type::relink(first0,first1);
      first1=tmp;
    }
    else first0=first0->next();
  }
  impl_type::relink(last0,first1,last1);
}






static const std::size_t sequenced_index_sort_max_fill= (std::size_t)std::numeric_limits<std::size_t>::digits+1


                                                            ;

template<typename Node,typename Compare>
void sequenced_index_sort(Node* header,Compare comp)
{
# 127 "/opt/sevenflow/boost/include/boost/multi_index/detail/seq_index_ops.hpp"
  if(header->next()==header->impl()||
     header->next()->next()==header->impl())return;

  typedef typename Node::impl_type impl_type;
  typedef typename Node::impl_pointer impl_pointer;

  typedef typename aligned_storage<
    sizeof(impl_type),
    alignment_of<impl_type>::value
  >::type carry_spc_type;
  carry_spc_type carry_spc;
  impl_type& carry=
    *static_cast<impl_type*>(static_cast<void*>(&carry_spc));
  typedef typename aligned_storage<
    sizeof(
      impl_type
        [sequenced_index_sort_max_fill]),
    alignment_of<
      impl_type
        [sequenced_index_sort_max_fill]
    >::value
  >::type counter_spc_type;
  counter_spc_type counter_spc;
  impl_type* counter=
    static_cast<impl_type*>(static_cast<void*>(&counter_spc));
  std::size_t fill=0;

  carry.prior()=carry.next()=static_cast<impl_pointer>(&carry);
  counter[0].prior()=counter[0].next()=static_cast<impl_pointer>(&counter[0]);

  { try{
    while(header->next()!=header->impl()){
      impl_type::relink(carry.next(),header->next());
      std::size_t i=0;
      while(i<fill&&counter[i].next()!=static_cast<impl_pointer>(&counter[i])){
        sequenced_index_collate<Node>(&carry,&counter[i++],comp);
      }
      impl_type::swap(
        static_cast<impl_pointer>(&carry),
        static_cast<impl_pointer>(&counter[i]));
      if(i==fill){
        ++fill;
        counter[fill].prior()=counter[fill].next()=
          static_cast<impl_pointer>(&counter[fill]);
      }
    }

    for(std::size_t i=1;i<fill;++i){
      sequenced_index_collate<Node>(&counter[i],&counter[i-1],comp);
    }
    impl_type::swap(
      header->impl(),static_cast<impl_pointer>(&counter[fill-1]));
  }
  catch(...)
  {
    impl_type::relink(
      header->impl(),carry.next(),static_cast<impl_pointer>(&carry));
    for(std::size_t i=0;i<=fill;++i){
      impl_type::relink(
        header->impl(),counter[i].next(),
        static_cast<impl_pointer>(&counter[i]));
    }
    throw;;
  }
  }
}

}

}

}
# 34 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index_fwd.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index_fwd.hpp"
namespace boost{

namespace multi_index{

namespace detail{

template<typename SuperMeta,typename TagList>
class sequenced_index;

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator==(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y);

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator<(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y);

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator!=(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y);

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator>(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y);

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator>=(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y);

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator<=(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y);

template<typename SuperMeta,typename TagList>
void swap(
  sequenced_index<SuperMeta,TagList>& x,
  sequenced_index<SuperMeta,TagList>& y);

}



template <typename TagList=tag<> >
struct sequenced;

}

}
# 35 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2


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


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 38 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2




# 1 "/opt/sevenflow/boost/include/boost/bind.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 1
# 26 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/mem_fn.hpp" 1
# 22 "/opt/sevenflow/boost/include/boost/mem_fn.hpp"
# 1 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp"
# 1 "/opt/sevenflow/boost/include/boost/get_pointer.hpp" 1
# 14 "/opt/sevenflow/boost/include/boost/get_pointer.hpp"
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();
}


}
# 26 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp" 2


namespace boost
{
# 207 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp"
namespace _mfi
{






# 1 "/opt/sevenflow/boost/include/boost/bind/mem_fn_template.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/bind/mem_fn_template.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp" 2
# 258 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp"
}
# 268 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp"
# 1 "/opt/sevenflow/boost/include/boost/bind/mem_fn_cc.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/bind/mem_fn_cc.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp" 2
# 311 "/opt/sevenflow/boost/include/boost/bind/mem_fn.hpp"
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 "/opt/sevenflow/boost/include/boost/mem_fn.hpp" 2
# 27 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/type.hpp" 1
# 9 "/opt/sevenflow/boost/include/boost/type.hpp"
namespace boost {



  template <class T>
  struct type {};

}
# 28 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/is_placeholder.hpp" 1
# 21 "/opt/sevenflow/boost/include/boost/is_placeholder.hpp"
namespace boost
{

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

}
# 29 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/bind/arg.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/bind/arg.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2

# 1 "/opt/sevenflow/boost/include/boost/visit_each.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/visit_each.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 41 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/bind/storage.hpp" 1
# 32 "/opt/sevenflow/boost/include/boost/bind/storage.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2






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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind_template.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/bind/bind_template.hpp"
    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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2


};
# 940 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/bind/bind_cc.hpp" 1
# 15 "/opt/sevenflow/boost/include/boost/bind/bind_cc.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 1595 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
# 1 "/opt/sevenflow/boost/include/boost/bind/bind_mf_cc.hpp" 1
# 17 "/opt/sevenflow/boost/include/boost/bind/bind_mf_cc.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 1 "/opt/sevenflow/boost/include/boost/bind/bind_mf2_cc.hpp" 1
# 18 "/opt/sevenflow/boost/include/boost/bind/bind_mf2_cc.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 1656 "/opt/sevenflow/boost/include/boost/bind/bind.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/placeholders.hpp" 1
# 25 "/opt/sevenflow/boost/include/boost/bind/placeholders.hpp"
namespace
{
# 55 "/opt/sevenflow/boost/include/boost/bind/placeholders.hpp"
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 "/opt/sevenflow/boost/include/boost/bind/bind.hpp" 2
# 23 "/opt/sevenflow/boost/include/boost/bind.hpp" 2
# 43 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp" 2
# 54 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
namespace boost{

namespace multi_index{

namespace detail{



template<typename SuperMeta,typename TagList>
class sequenced_index:
  protected SuperMeta::type
# 78 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
{
# 89 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
  typedef typename SuperMeta::type super;

protected:
  typedef sequenced_index_node<
    typename super::node_type> node_type;

private:
  typedef typename node_type::impl_type node_impl_type;

public:


  typedef typename node_type::value_type value_type;
  typedef tuples::null_type ctor_args;
  typedef typename super::final_allocator_type allocator_type;
  typedef typename allocator_type::reference reference;
  typedef typename allocator_type::const_reference const_reference;
# 119 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
  typedef bidir_node_iterator<node_type> iterator;


  typedef iterator const_iterator;

  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;
  typedef typename allocator_type::pointer pointer;
  typedef typename allocator_type::const_pointer const_pointer;
  typedef typename
    boost::reverse_iterator<iterator> reverse_iterator;
  typedef typename
    boost::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef TagList tag_list;

protected:
  typedef typename super::final_node_type final_node_type;
  typedef tuples::cons<
    ctor_args,
    typename super::ctor_args_list> ctor_args_list;
  typedef typename mpl::push_front<
    typename super::index_type_list,
    sequenced_index>::type index_type_list;
  typedef typename mpl::push_front<
    typename super::iterator_type_list,
    iterator>::type iterator_type_list;
  typedef typename mpl::push_front<
    typename super::const_iterator_type_list,
    const_iterator>::type const_iterator_type_list;
  typedef typename super::copy_map_type copy_map_type;


  typedef typename super::index_saver_type index_saver_type;
  typedef typename super::index_loader_type index_loader_type;


private:
# 167 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
  typedef typename call_traits<value_type>::param_type value_param_type;

public:






  sequenced_index<SuperMeta,TagList>& operator=(
    const sequenced_index<SuperMeta,TagList>& x)
  {
    this->final()=x.final();
    return *this;
  }

  template <class InputIterator>
  void assign(InputIterator first,InputIterator last)
  {
    assign_iter(first,last,mpl::not_<is_integral<InputIterator> >());
  }

  void assign(size_type n,value_param_type value)
  {
    ;
    clear();
    for(size_type i=0;i<n;++i)push_back(value);
  }

  allocator_type get_allocator()const
  {
    return this->final().get_allocator();
  }



  iterator begin()
    {return make_iterator(node_type::from_impl(header()->next()));}
  const_iterator begin()const
    {return make_iterator(node_type::from_impl(header()->next()));}
  iterator end(){return make_iterator(header());}
  const_iterator end()const{return make_iterator(header());}
  reverse_iterator rbegin(){return make_reverse_iterator(end());}
  const_reverse_iterator rbegin()const{return make_reverse_iterator(end());}
  reverse_iterator rend(){return make_reverse_iterator(begin());}
  const_reverse_iterator rend()const{return make_reverse_iterator(begin());}
  const_iterator cbegin()const{return begin();}
  const_iterator cend()const{return end();}
  const_reverse_iterator crbegin()const{return rbegin();}
  const_reverse_iterator crend()const{return rend();}

  iterator iterator_to(const value_type& x)
  {
    return make_iterator(node_from_value<node_type>(&x));
  }

  const_iterator iterator_to(const value_type& x)const
  {
    return make_iterator(node_from_value<node_type>(&x));
  }



  bool empty()const{return this->final_empty_();}
  size_type size()const{return this->final_size_();}
  size_type max_size()const{return this->final_max_size_();}

  void resize(size_type n,value_param_type x=value_type())
  {
    ;
    if(n>size())insert(end(),n-size(),x);
    else if(n<size()){
      iterator it;
      if(n<=size()/2){
        it=begin();
        std::advance(it,n);
      }
      else{
        it=end();
        for(size_type m=size()-n;m--;--it){}
      }
      erase(it,end());
    }
  }





  const_reference front()const{return *begin();}
  const_reference back()const{return *--end();}



  std::pair<iterator,bool> push_front(value_param_type x)
                             {return insert(begin(),x);}
  void pop_front(){erase(begin());}
  std::pair<iterator,bool> push_back(value_param_type x)
                             {return insert(end(),x);}
  void pop_back(){erase(--end());}

  std::pair<iterator,bool> insert(iterator position,value_param_type x)
  {
    ((void)0);;
    ((void)0);;
    ;
    std::pair<final_node_type*,bool> p=this->final_insert_(x);
    if(p.second&&position.get_node()!=header()){
      relink(position.get_node(),p.first);
    }
    return std::pair<iterator,bool>(make_iterator(p.first),p.second);
  }

  void insert(iterator position,size_type n,value_param_type x)
  {
    ((void)0);;
    ((void)0);;
    ;
    for(size_type i=0;i<n;++i)insert(position,x);
  }

  template<typename InputIterator>
  void insert(iterator position,InputIterator first,InputIterator last)
  {
    insert_iter(position,first,last,mpl::not_<is_integral<InputIterator> >());
  }

  iterator erase(iterator position)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    this->final_erase_(static_cast<final_node_type*>(position++.get_node()));
    return position;
  }

  iterator erase(iterator first,iterator last)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    while(first!=last){
      first=erase(first);
    }
    return first;
  }

  bool replace(iterator position,value_param_type x)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    return this->final_replace_(
      x,static_cast<final_node_type*>(position.get_node()));
  }

  template<typename Modifier>
  bool modify(iterator position,Modifier mod)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
# 345 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
    return this->final_modify_(
      mod,static_cast<final_node_type*>(position.get_node()));
  }

  template<typename Modifier,typename Rollback>
  bool modify(iterator position,Modifier mod,Rollback back)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
# 366 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
    return this->final_modify_(
      mod,back,static_cast<final_node_type*>(position.get_node()));
  }

  void swap(sequenced_index<SuperMeta,TagList>& x)
  {
    ;
    this->final_swap_(x.final());
  }

  void clear()
  {
    ;
    this->final_clear_();
  }



  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    iterator first=x.begin(),last=x.end();
    while(first!=last){
      if(insert(position,*first).second)first=x.erase(first);
      else ++first;
    }
  }

  void splice(iterator position,sequenced_index<SuperMeta,TagList>& x,iterator i)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    if(&x==this){
      if(position!=i)relink(position.get_node(),i.get_node());
    }
    else{
      if(insert(position,*i).second){
# 419 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
        x.erase(i);


      }
    }
  }

  void splice(
    iterator position,sequenced_index<SuperMeta,TagList>& x,
    iterator first,iterator last)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    if(&x==this){
      ((void)0);;
      if(position!=last)relink(
        position.get_node(),first.get_node(),last.get_node());
    }
    else{
      while(first!=last){
        if(insert(position,*first).second)first=x.erase(first);
        else ++first;
      }
    }
  }

  void remove(value_param_type value)
  {
    sequenced_index_remove(
      *this,std::bind2nd(std::equal_to<value_type>(),value));
  }

  template<typename Predicate>
  void remove_if(Predicate pred)
  {
    sequenced_index_remove(*this,pred);
  }

  void unique()
  {
    sequenced_index_unique(*this,std::equal_to<value_type>());
  }

  template <class BinaryPredicate>
  void unique(BinaryPredicate binary_pred)
  {
    sequenced_index_unique(*this,binary_pred);
  }

  void merge(sequenced_index<SuperMeta,TagList>& x)
  {
    sequenced_index_merge(*this,x,std::less<value_type>());
  }

  template <typename Compare>
  void merge(sequenced_index<SuperMeta,TagList>& x,Compare comp)
  {
    sequenced_index_merge(*this,x,comp);
  }

  void sort()
  {
    ;
    sequenced_index_sort(header(),std::less<value_type>());
  }

  template <typename Compare>
  void sort(Compare comp)
  {
    ;
    sequenced_index_sort(header(),comp);
  }

  void reverse()
  {
    ;
    node_impl_type::reverse(header()->impl());
  }



  void relocate(iterator position,iterator i)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    if(position!=i)relink(position.get_node(),i.get_node());
  }

  void relocate(iterator position,iterator first,iterator last)
  {
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ((void)0);;
    ;
    if(position!=last)relink(
      position.get_node(),first.get_node(),last.get_node());
  }

  template<typename InputIterator>
  void rearrange(InputIterator first)
  {
    ;
    node_type* pos=header();
    for(size_type s=size();s--;){
      const value_type& v=*first++;
      relink(pos,node_from_value<node_type>(&v));
    }
  }

protected:
  sequenced_index(const ctor_args_list& args_list,const allocator_type& al):
    super(args_list.get_tail(),al)
  {
    empty_initialize();
  }

  sequenced_index(const sequenced_index<SuperMeta,TagList>& x):
    super(x)





  {


  }

  ~sequenced_index()
  {

  }






  iterator make_iterator(node_type* node){return iterator(node);}
  const_iterator make_iterator(node_type* node)const
                   {return const_iterator(node);}


  void copy_(
    const sequenced_index<SuperMeta,TagList>& x,const copy_map_type& map)
  {
    node_type* org=x.header();
    node_type* cpy=header();
    do{
      node_type* next_org=node_type::from_impl(org->next());
      node_type* next_cpy=map.find(static_cast<final_node_type*>(next_org));
      cpy->next()=next_cpy->impl();
      next_cpy->prior()=cpy->impl();
      org=next_org;
      cpy=next_cpy;
    }while(org!=x.header());

    super::copy_(x,map);
  }

  node_type* insert_(value_param_type v,node_type* x)
  {
    node_type* res=static_cast<node_type*>(super::insert_(v,x));
    if(res==x)link(x);
    return res;
  }

  node_type* insert_(value_param_type v,node_type* position,node_type* x)
  {
    node_type* res=static_cast<node_type*>(super::insert_(v,position,x));
    if(res==x)link(x);
    return res;
  }

  void erase_(node_type* x)
  {
    unlink(x);
    super::erase_(x);




  }

  void delete_all_nodes_()
  {
    for(node_type* x=node_type::from_impl(header()->next());x!=header();){
      node_type* y=node_type::from_impl(x->next());
      this->final_delete_node_(static_cast<final_node_type*>(x));
      x=y;
    }
  }

  void clear_()
  {
    super::clear_();
    empty_initialize();




  }

  void swap_(sequenced_index<SuperMeta,TagList>& x)
  {




    super::swap_(x);
  }

  bool replace_(value_param_type v,node_type* x)
  {
    return super::replace_(v,x);
  }

  bool modify_(node_type* x)
  {
    { try{
      if(!super::modify_(x)){
        unlink(x);





        return false;
      }
      else return true;
    }
    catch(...){
      unlink(x);





      throw;;
    }
    }
  }

  bool modify_rollback_(node_type* x)
  {
    return super::modify_rollback_(x);
  }




  template<typename Archive>
  void save_(
    Archive& ar,const unsigned int version,const index_saver_type& sm)const
  {
    sm.save(begin(),end(),ar,version);
    super::save_(ar,version,sm);
  }

  template<typename Archive>
  void load_(
    Archive& ar,const unsigned int version,const index_loader_type& lm)
  {
    lm.load(
      ::boost::bind(&sequenced_index::rearranger,this,_1,_2),
      ar,version);
    super::load_(ar,version,lm);
  }
# 733 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
private:
  node_type* header()const{return this->final_header();}

  void empty_initialize()
  {
    header()->prior()=header()->next()=header()->impl();
  }

  void link(node_type* x)
  {
    node_impl_type::link(x->impl(),header()->impl());
  };

  static void unlink(node_type* x)
  {
    node_impl_type::unlink(x->impl());
  }

  static void relink(node_type* position,node_type* x)
  {
    node_impl_type::relink(position->impl(),x->impl());
  }

  static void relink(node_type* position,node_type* first,node_type* last)
  {
    node_impl_type::relink(
      position->impl(),first->impl(),last->impl());
  }


  void rearranger(node_type* position,node_type *x)
  {
    if(!position)position=header();
    node_type::increment(position);
    if(position!=x)relink(position,x);
  }
# 779 "/opt/sevenflow/boost/include/boost/multi_index/sequenced_index.hpp"
  template <class InputIterator>
  void assign_iter(InputIterator first,InputIterator last,mpl::true_)
  {
    ;
    clear();
    for(;first!=last;++first)push_back(*first);
  }

  void assign_iter(size_type n,value_param_type value,mpl::false_)
  {
    ;
    clear();
    for(size_type i=0;i<n;++i)push_back(value);
  }

  template<typename InputIterator>
  void insert_iter(
    iterator position,InputIterator first,InputIterator last,mpl::true_)
  {
    ;
    for(;first!=last;++first)insert(position,*first);
  }

  void insert_iter(
    iterator position,size_type n,value_param_type x,mpl::false_)
  {
    ((void)0);;
    ((void)0);;
    ;
    for(size_type i=0;i<n;++i)insert(position,x);
  }





};



template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator==(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y)
{
  return x.size()==y.size()&&std::equal(x.begin(),x.end(),y.begin());
}

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator<(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y)
{
  return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
}

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator!=(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y)
{
  return !(x==y);
}

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator>(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y)
{
  return y<x;
}

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator>=(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y)
{
  return !(x<y);
}

template<
  typename SuperMeta1,typename TagList1,
  typename SuperMeta2,typename TagList2
>
bool operator<=(
  const sequenced_index<SuperMeta1,TagList1>& x,
  const sequenced_index<SuperMeta2,TagList2>& y)
{
  return !(x>y);
}



template<typename SuperMeta,typename TagList>
void swap(
  sequenced_index<SuperMeta,TagList>& x,
  sequenced_index<SuperMeta,TagList>& y)
{
  x.swap(y);
}

}



template <typename TagList>
struct sequenced
{
  typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((detail::is_tag<TagList>::value) == 0 ? false : true) >)> boost_static_assert_typedef_902;

  template<typename Super>
  struct node_class
  {
    typedef detail::sequenced_index_node<Super> type;
  };

  template<typename SuperMeta>
  struct index_class
  {
    typedef detail::sequenced_index<SuperMeta,typename TagList::type> type;
  };
};

}

}



template<typename SuperMeta,typename TagList>
inline boost::mpl::true_* boost_foreach_is_noncopyable(
  boost::multi_index::detail::sequenced_index<SuperMeta,TagList>*&,
  boost::foreach::tag)
{
  return 0;
}
# 6 "test.cpp" 2
# 1 "/opt/sevenflow/boost/include/boost/multi_index/member.hpp" 1
# 20 "/opt/sevenflow/boost/include/boost/multi_index/member.hpp"
# 1 "/usr/include/c++/4.8.2/cstddef" 1 3
# 39 "/usr/include/c++/4.8.2/cstddef" 3
       
# 40 "/usr/include/c++/4.8.2/cstddef" 3


# 1 "/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h" 1 3 4
# 42 "/usr/include/c++/4.8.2/cstddef" 2 3
# 21 "/opt/sevenflow/boost/include/boost/multi_index/member.hpp" 2





namespace boost{

template<class T> class reference_wrapper;

namespace multi_index{

namespace detail{
# 54 "/opt/sevenflow/boost/include/boost/multi_index/member.hpp"
template<class Class,typename Type,Type Class::*PtrToMember>
struct const_member_base
{
  typedef Type result_type;

  template<typename ChainedPtr>


  typename disable_if<
    is_convertible<const ChainedPtr&,const Class&>,Type&>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  Type& operator()(const Class& x)const
  {
    return x.*PtrToMember;
  }

  Type& operator()(const reference_wrapper<const Class>& x)const
  {
    return operator()(x.get());
  }

  Type& operator()(const reference_wrapper<Class>& x,int=0)const
  {
    return operator()(x.get());
  }
};

template<class Class,typename Type,Type Class::*PtrToMember>
struct non_const_member_base
{
  typedef Type result_type;

  template<typename ChainedPtr>


  typename disable_if<
    is_convertible<const ChainedPtr&,const Class&>,Type&>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  const Type& operator()(const Class& x,int=0)const
  {
    return x.*PtrToMember;
  }

  Type& operator()(Class& x)const
  {
    return x.*PtrToMember;
  }

  const Type& operator()(const reference_wrapper<const Class>& x,int=0)const
  {
    return operator()(x.get());
  }

  Type& operator()(const reference_wrapper<Class>& x)const
  {
    return operator()(x.get());
  }
};

}

template<class Class,typename Type,Type Class::*PtrToMember>
struct member:
  mpl::if_c<
    is_const<Type>::value,
    detail::const_member_base<Class,Type,PtrToMember>,
    detail::non_const_member_base<Class,Type,PtrToMember>
  >::type
{
};

namespace detail{
# 157 "/opt/sevenflow/boost/include/boost/multi_index/member.hpp"
template<class Class,typename Type,std::size_t OffsetOfMember>
struct const_member_offset_base
{
  typedef Type result_type;

  template<typename ChainedPtr>


  typename disable_if<
    is_convertible<const ChainedPtr&,const Class&>,Type&>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  Type& operator()(const Class& x)const
  {
    return *static_cast<const Type*>(
      static_cast<const void*>(
        static_cast<const char*>(
          static_cast<const void *>(&x))+OffsetOfMember));
  }

  Type& operator()(const reference_wrapper<const Class>& x)const
  {
    return operator()(x.get());
  }

  Type& operator()(const reference_wrapper<Class>& x,int=0)const
  {
    return operator()(x.get());
  }
};

template<class Class,typename Type,std::size_t OffsetOfMember>
struct non_const_member_offset_base
{
  typedef Type result_type;

  template<typename ChainedPtr>


  typename disable_if<
    is_convertible<const ChainedPtr&,const Class&>,Type&>::type




  operator()(const ChainedPtr& x)const
  {
    return operator()(*x);
  }

  const Type& operator()(const Class& x,int=0)const
  {
    return *static_cast<const Type*>(
      static_cast<const void*>(
        static_cast<const char*>(
          static_cast<const void *>(&x))+OffsetOfMember));
  }

  Type& operator()(Class& x)const
  {
    return *static_cast<Type*>(
      static_cast<void*>(
        static_cast<char*>(static_cast<void *>(&x))+OffsetOfMember));
  }

  const Type& operator()(const reference_wrapper<const Class>& x,int=0)const
  {
    return operator()(x.get());
  }

  Type& operator()(const reference_wrapper<Class>& x)const
  {
    return operator()(x.get());
  }
};

}

template<class Class,typename Type,std::size_t OffsetOfMember>
struct member_offset:
  mpl::if_c<
    is_const<Type>::value,
    detail::const_member_offset_base<Class,Type,OffsetOfMember>,
    detail::non_const_member_offset_base<Class,Type,OffsetOfMember>
  >::type
{
};
# 265 "/opt/sevenflow/boost/include/boost/multi_index/member.hpp"
}

}
# 7 "test.cpp" 2

typedef boost::interprocess::managed_shared_memory::segment_manager segment_manager_t;

using namespace boost::multi_index;

typedef struct element {
    int a;
    int b;
    int c;
    int d;
} element_t;

typedef multi_index_container<element,
    indexed_by<
     hashed_unique<
            composite_key<element,
                member<element, int, &element::a>,
                member<element, int, &element::b>,
                member<element, int, &element::c> > >,
        hashed_non_unique<
            composite_key<element,
                member<element, int, &element::b>,
                member<element, int, &element::c> > >
    >
> myMap;

typedef multi_index_container<element,
    indexed_by<
     hashed_unique<
            composite_key<element,
                member<element, int, &element::a>,
                member<element, int, &element::b>,
                member<element, int, &element::c> > >,

        ordered_non_unique<
            composite_key<element,
             member<element, int, &element::b>,
             member<element, int, &element::c>,
                member<element, int, &element::d> > >
    >,
    boost::interprocess::allocator<element, segment_manager_t>
> myShmMap;

int main(int argc, char **argv)
{
    element elem;

    boost::interprocess::managed_shared_memory* segment;
    segment = new boost::interprocess::managed_shared_memory(boost::interprocess::open_or_create, "test", 4096);
    myShmMap *testMap = segment->find_or_construct<myShmMap>("test")(myShmMap::ctor_args_list(), segment->get_segment_manager());
    testMap->insert(elem);




    return 0;
}