// /usr/lib/gcc/x86_64-linux-gnu/4.1.3/cc1plus -quiet -I/scratch/mcrl2_regressiontest/trunk/libraries/core/include -I/scratch/mcrl2_regressiontest/trunk/libraries/data/include -I/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm -I/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include -I/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include -I/scratch/mcrl2_regressiontest/trunk/build/workarounds -D_GNU_SOURCE -D_REENTRANT -DAT_64BIT -D_FILE_OFFSET_BITS=64 -D_LARGE_FILES -D__WXGTK__ -DMCRL2_TEST_COMPILERS -isystem /usr/lib/wx/include/gtk2-unicode-release-2.8 -isystem /usr/include/wx-2.8 /scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp -quiet -dumpbase print_c.cpp -mtune=generic -auxbase-strip CMakeFiles/mcrl2_core.dir/source/print_c.cpp.o -g -O0 -W -Wunused-variable -Wunused-parameter -Wunused-function -Wunused -Wno-system-headers -Woverloaded-virtual -Wwrite-strings -Wall -Wno-inline -fprofile-arcs -ftest-coverage -fstack-protector -fstack-protector -o - -frandom-seed=0
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp"
# 1 "/scratch/mcrl2_regressiontest/gcc-4.1-Maintainer-shared-OFF/libraries/core//"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp"
# 11 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp"
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 26 "/usr/include/boost/cstdint.hpp" 3 4
# 1 "/usr/include/boost/config.hpp" 1 3 4
# 26 "/usr/include/boost/config.hpp" 3 4
# 1 "/usr/include/boost/config/user.hpp" 1 3 4
# 27 "/usr/include/boost/config.hpp" 2 3 4




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



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




# 1 "/usr/include/boost/config/select_stdlib_config.hpp" 1 3 4
# 17 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
# 1 "/usr/include/c++/4.1.3/cstddef" 1 3 4
# 48 "/usr/include/c++/4.1.3/cstddef" 3 4
       
# 49 "/usr/include/c++/4.1.3/cstddef" 3

# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 152 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 3 4
typedef long int ptrdiff_t;
# 214 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 3 4
typedef long unsigned int size_t;
# 51 "/usr/include/c++/4.1.3/cstddef" 2 3

namespace std
{
  using ::ptrdiff_t;
  using ::size_t;
}
# 18 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
# 33 "/usr/include/boost/config/select_stdlib_config.hpp" 3 4
# 1 "/usr/include/boost/config/no_tr1/utility.hpp" 1 3 4
# 21 "/usr/include/boost/config/no_tr1/utility.hpp" 3 4
# 1 "/usr/include/c++/4.1.3/utility" 1 3 4
# 63 "/usr/include/c++/4.1.3/utility" 3 4
       
# 64 "/usr/include/c++/4.1.3/utility" 3

# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++config.h" 1 3
# 35 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++config.h" 3
# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/os_defines.h" 1 3
# 39 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 313 "/usr/include/features.h" 3 4
# 1 "/usr/include/bits/predefs.h" 1 3 4
# 314 "/usr/include/features.h" 2 3 4
# 346 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 353 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 354 "/usr/include/sys/cdefs.h" 2 3 4
# 347 "/usr/include/features.h" 2 3 4
# 378 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4



# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 5 "/usr/include/gnu/stubs.h" 2 3 4




# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 2 3 4
# 379 "/usr/include/features.h" 2 3 4
# 40 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/os_defines.h" 2 3
# 36 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++config.h" 2 3


# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/cpu_defines.h" 1 3
# 39 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++config.h" 2 3




namespace __gnu_debug_def { }

namespace __gnu_debug
{
  using namespace __gnu_debug_def;
}
# 66 "/usr/include/c++/4.1.3/utility" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_relops.h" 1 3
# 74 "/usr/include/c++/4.1.3/bits/stl_relops.h" 3
namespace std
{
  namespace rel_ops
  {
# 90 "/usr/include/c++/4.1.3/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 103 "/usr/include/c++/4.1.3/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 116 "/usr/include/c++/4.1.3/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 129 "/usr/include/c++/4.1.3/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }

  }
}
# 67 "/usr/include/c++/4.1.3/utility" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_pair.h" 1 3
# 64 "/usr/include/c++/4.1.3/bits/stl_pair.h" 3
namespace std
{

  template<class _T1, class _T2>
    struct pair
    {
      typedef _T1 first_type;
      typedef _T2 second_type;

      _T1 first;
      _T2 second;





      pair()
      : first(), second() { }


      pair(const _T1& __a, const _T2& __b)
      : first(__a), second(__b) { }


      template<class _U1, class _U2>
        pair(const pair<_U1, _U2>& __p)
 : first(__p.first), second(__p.second) { }
    };


  template<class _T1, class _T2>
    inline bool
    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first == __y.first && __x.second == __y.second; }


  template<class _T1, class _T2>
    inline bool
    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __x.first < __y.first
      || (!(__y.first < __x.first) && __x.second < __y.second); }


  template<class _T1, class _T2>
    inline bool
    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x == __y); }


  template<class _T1, class _T2>
    inline bool
    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return __y < __x; }


  template<class _T1, class _T2>
    inline bool
    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__y < __x); }


  template<class _T1, class _T2>
    inline bool
    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    { return !(__x < __y); }
# 142 "/usr/include/c++/4.1.3/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); }
}
# 68 "/usr/include/c++/4.1.3/utility" 2 3
# 22 "/usr/include/boost/config/no_tr1/utility.hpp" 2 3 4
# 34 "/usr/include/boost/config/select_stdlib_config.hpp" 2 3 4
# 41 "/usr/include/boost/config.hpp" 2 3 4



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




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



# 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
# 14 "/usr/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/include/c++/4.1.3/cstdlib" 1 3 4
# 48 "/usr/include/c++/4.1.3/cstdlib" 3 4
       
# 49 "/usr/include/c++/4.1.3/cstdlib" 3
# 71 "/usr/include/c++/4.1.3/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 33 "/usr/include/stdlib.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 34 "/usr/include/stdlib.h" 2 3 4

extern "C" {






# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 43 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 65 "/usr/include/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 38 "/usr/include/endian.h" 2 3 4
# 61 "/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
# 62 "/usr/include/endian.h" 2 3 4
# 66 "/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;
  };
# 44 "/usr/include/stdlib.h" 2 3 4
# 96 "/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;


# 140 "/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))) ;

# 236 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/xlocale.h" 1 3 4
# 28 "/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;
# 237 "/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))) ;
# 311 "/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
# 29 "/usr/include/sys/types.h" 3 4
extern "C" {

# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/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;
# 131 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 132 "/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 long int __swblk_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


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


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

typedef long int __ssize_t;



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


typedef long int __intptr_t;


typedef unsigned int __socklen_t;
# 32 "/usr/include/sys/types.h" 2 3 4



typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;




typedef __loff_t loff_t;





typedef __ino64_t ino_t;




typedef __ino64_t ino64_t;




typedef __dev_t dev_t;




typedef __gid_t gid_t;




typedef __mode_t mode_t;




typedef __nlink_t nlink_t;




typedef __uid_t uid_t;







typedef __off64_t off_t;




typedef __off64_t off64_t;




typedef __pid_t pid_t;




typedef __id_t id_t;




typedef __ssize_t ssize_t;





typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;
# 133 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 58 "/usr/include/time.h" 3 4


typedef __clock_t clock_t;



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


typedef __time_t time_t;



# 92 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 104 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 134 "/usr/include/sys/types.h" 2 3 4



typedef __useconds_t useconds_t;



typedef __suseconds_t suseconds_t;





# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 148 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 195 "/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__)));
# 220 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/sys/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 23 "/usr/include/bits/select.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/select.h" 2 3 4
# 32 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/sigset.h" 1 3 4
# 24 "/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;
# 35 "/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;
    long int tv_nsec;
  };
# 45 "/usr/include/sys/select.h" 2 3 4

# 1 "/usr/include/bits/time.h" 1 3 4
# 69 "/usr/include/bits/time.h" 3 4
struct timeval
  {
    __time_t tv_sec;
    __suseconds_t tv_usec;
  };
# 47 "/usr/include/sys/select.h" 2 3 4
# 55 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 67 "/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;
# 99 "/usr/include/sys/select.h" 3 4
extern "C" {
# 109 "/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);
# 121 "/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);


}
# 221 "/usr/include/sys/types.h" 2 3 4


# 1 "/usr/include/sys/sysmacros.h" 1 3 4
# 30 "/usr/include/sys/sysmacros.h" 3 4
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
     throw ();
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
     throw ();
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
            unsigned int __minor)
     throw ();
# 224 "/usr/include/sys/types.h" 2 3 4




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



typedef __fsblkcnt64_t fsblkcnt_t;



typedef __fsfilcnt64_t fsfilcnt_t;





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





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
# 50 "/usr/include/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;


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



typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;
# 76 "/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;
# 101 "/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;
# 187 "/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


}
# 321 "/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
# 25 "/usr/include/alloca.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 26 "/usr/include/alloca.h" 2 3 4

extern "C" {





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





}
# 498 "/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 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 ();






extern int clearenv (void) throw ();
# 604 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 618 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __asm__ ("" "mkstemp64")
     __attribute__ ((__nonnull__ (1))) ;





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






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





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) __asm__ ("" "mkostemps64")

     __attribute__ ((__nonnull__ (1))) ;





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))) ;
# 729 "/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__)) ;

# 802 "/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))) ;
# 890 "/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)));
# 958 "/usr/include/stdlib.h" 3 4
}
# 72 "/usr/include/c++/4.1.3/cstdlib" 2 3
# 103 "/usr/include/c++/4.1.3/cstdlib" 3
namespace std
{
  using ::div_t;
  using ::ldiv_t;

  using ::abort;
  using ::abs;
  using ::atexit;
  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;

  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;

  using ::qsort;
  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;


  inline long
  abs(long __i) { return labs(__i); }

  inline ldiv_t
  div(long __i, long __j) { return ldiv(__i, __j); }
}
# 159 "/usr/include/c++/4.1.3/cstdlib" 3
namespace __gnu_cxx
{

  using ::lldiv_t;





  using ::_Exit;


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


  using ::llabs;

  inline lldiv_t
  div(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }

  using ::lldiv;
# 192 "/usr/include/c++/4.1.3/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::abs;

  using ::__gnu_cxx::llabs;
  using ::__gnu_cxx::div;
  using ::__gnu_cxx::lldiv;

  using ::__gnu_cxx::atoll;
  using ::__gnu_cxx::strtof;
  using ::__gnu_cxx::strtoll;
  using ::__gnu_cxx::strtoull;
  using ::__gnu_cxx::strtold;
}
# 15 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
# 70 "/usr/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/include/boost/config/posix_features.hpp" 1 3 4
# 18 "/usr/include/boost/config/posix_features.hpp" 3 4
# 1 "/usr/include/unistd.h" 1 3 4
# 28 "/usr/include/unistd.h" 3 4
extern "C" {
# 203 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 204 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 23 "/usr/include/bits/environments.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/environments.h" 2 3 4
# 208 "/usr/include/unistd.h" 2 3 4
# 227 "/usr/include/unistd.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 228 "/usr/include/unistd.h" 2 3 4
# 268 "/usr/include/unistd.h" 3 4
typedef __intptr_t intptr_t;






typedef __socklen_t socklen_t;
# 288 "/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 __off64_t lseek (int __fd, __off64_t __offset, int __whence) throw () __asm__ ("" "lseek64");







extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     throw ();






extern int close (int __fd);






extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ;





extern ssize_t write (int __fd, __const void *__buf, size_t __n) ;
# 385 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64") ;


extern ssize_t pwrite (int __fd, __const void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pwrite64") ;
# 401 "/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 () ;
# 429 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) throw ();
# 441 "/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);
# 465 "/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 () ;
# 507 "/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)));




extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
     throw ();




extern int execv (__const char *__path, char *__const __argv[])
     throw () __attribute__ ((__nonnull__ (1)));



extern int execle (__const char *__path, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));



extern int execl (__const char *__path, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));



extern int execvp (__const char *__file, char *__const __argv[])
     throw () __attribute__ ((__nonnull__ (1)));




extern int execlp (__const char *__file, __const char *__arg, ...)
     throw () __attribute__ ((__nonnull__ (1)));




extern int execvpe (__const char *__file, char *__const __argv[],
      char *__const __envp[])
     throw () __attribute__ ((__nonnull__ (1)));





extern int nice (int __inc) throw () ;




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





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

  };
# 605 "/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 ();
# 641 "/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 ();
# 667 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) throw ();
# 684 "/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)));
# 887 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/getopt.h" 1 3 4
# 50 "/usr/include/getopt.h" 3 4
extern "C" {
# 59 "/usr/include/getopt.h" 3 4
extern char *optarg;
# 73 "/usr/include/getopt.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 152 "/usr/include/getopt.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       throw ();
# 187 "/usr/include/getopt.h" 3 4
}
# 888 "/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)));
# 973 "/usr/include/unistd.h" 3 4
extern int fsync (int __fd);






extern long int gethostid (void);


extern void sync (void) throw ();




extern int getpagesize (void) throw () __attribute__ ((__const__));




extern int getdtablesize (void) throw ();
# 1002 "/usr/include/unistd.h" 3 4
extern int truncate (__const char *__file, __off64_t __length) throw () __asm__ ("" "truncate64") __attribute__ ((__nonnull__ (1))) ;







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






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





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






extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1115 "/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)));







extern char *ctermid (char *__s) throw ();
# 1153 "/usr/include/unistd.h" 3 4
}
# 19 "/usr/include/boost/config/posix_features.hpp" 2 3 4
# 71 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
# 54 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/suffix.hpp" 1 3 4
# 468 "/usr/include/boost/config/suffix.hpp" 3 4
namespace boost{

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




}
# 58 "/usr/include/boost/config.hpp" 2 3 4
# 27 "/usr/include/boost/cstdint.hpp" 2 3 4
# 42 "/usr/include/boost/cstdint.hpp" 3 4
# 1 "/usr/include/stdint.h" 1 3 4
# 27 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/wchar.h" 1 3 4
# 28 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 49 "/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;
# 66 "/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;
# 91 "/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;
# 104 "/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;
# 123 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 135 "/usr/include/stdint.h" 3 4
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
# 43 "/usr/include/boost/cstdint.hpp" 2 3 4
# 85 "/usr/include/boost/cstdint.hpp" 3 4
namespace boost
{

  using ::int8_t;
  using ::int_least8_t;
  using ::int_fast8_t;
  using ::uint8_t;
  using ::uint_least8_t;
  using ::uint_fast8_t;

  using ::int16_t;
  using ::int_least16_t;
  using ::int_fast16_t;
  using ::uint16_t;
  using ::uint_least16_t;
  using ::uint_fast16_t;

  using ::int32_t;
  using ::int_least32_t;
  using ::int_fast32_t;
  using ::uint32_t;
  using ::uint_least32_t;
  using ::uint_fast32_t;



  using ::int64_t;
  using ::int_least64_t;
  using ::int_fast64_t;
  using ::uint64_t;
  using ::uint_least64_t;
  using ::uint_fast64_t;



  using ::intmax_t;
  using ::uintmax_t;

}
# 12 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h"
# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4
# 45 "/usr/include/stdio.h" 3 4
struct _IO_FILE;



typedef struct _IO_FILE FILE;





# 65 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 75 "/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-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 16 "/usr/include/_G_config.h" 2 3 4




# 1 "/usr/include/wchar.h" 1 3 4
# 83 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {

    unsigned int __wch;



    char __wchb[4];
  } __value;
} __mbstate_t;
# 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;
# 53 "/usr/include/_G_config.h" 3 4
typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3 4
# 53 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4
# 170 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 180 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 203 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 271 "/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;
# 319 "/usr/include/libio.h" 3 4
  __off64_t _offset;
# 328 "/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_;
# 364 "/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);
# 460 "/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 ();
# 490 "/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 ();
# 552 "/usr/include/libio.h" 3 4
}
# 76 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
# 89 "/usr/include/stdio.h" 3 4




typedef _G_fpos64_t fpos_t;



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



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






extern FILE *tmpfile64 (void) ;



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





extern char *tmpnam_r (char *__s) throw () ;
# 204 "/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);

# 229 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 239 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);




# 260 "/usr/include/stdio.h" 3 4
extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) __asm__ ("" "fopen64")

  ;
extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) __asm__ ("" "freopen64")


  ;







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))) ;
# 394 "/usr/include/stdio.h" 3 4
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 ();
# 445 "/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)));
# 504 "/usr/include/stdio.h" 3 4









extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);





extern int getchar (void);

# 532 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 543 "/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);

# 576 "/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)
     ;






extern char *gets (char *__s) ;

# 622 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream) ;
# 638 "/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);

# 699 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
      FILE *__restrict __stream);
# 710 "/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);

# 754 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) __asm__ ("" "fseeko64");


extern __off64_t ftello (FILE *__stream) __asm__ ("" "ftello64");








# 779 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) __asm__ ("" "fgetpos64");

extern int fsetpos (FILE *__stream, __const fpos_t *__pos) __asm__ ("" "fsetpos64");









extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
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
# 27 "/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[];
# 827 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw () ;




extern int fileno_unlocked (FILE *__stream) throw () ;
# 846 "/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 ();
# 916 "/usr/include/stdio.h" 3 4
}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 2
# 1 "/usr/include/ctype.h" 1 3 4
# 30 "/usr/include/ctype.h" 3 4
extern "C" {
# 48 "/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))
};
# 81 "/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));
# 96 "/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 ();
# 247 "/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 ();
# 323 "/usr/include/ctype.h" 3 4
}
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 2
# 1 "/usr/include/assert.h" 1 3 4
# 68 "/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__));


}
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 2

# 1 "/usr/include/c++/4.1.3/ostream" 1 3
# 42 "/usr/include/c++/4.1.3/ostream" 3
       
# 43 "/usr/include/c++/4.1.3/ostream" 3

# 1 "/usr/include/c++/4.1.3/ios" 1 3
# 41 "/usr/include/c++/4.1.3/ios" 3
       
# 42 "/usr/include/c++/4.1.3/ios" 3

# 1 "/usr/include/c++/4.1.3/iosfwd" 1 3
# 42 "/usr/include/c++/4.1.3/iosfwd" 3
       
# 43 "/usr/include/c++/4.1.3/iosfwd" 3


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

# 1 "/usr/include/c++/4.1.3/cstring" 1 3
# 48 "/usr/include/c++/4.1.3/cstring" 3
       
# 49 "/usr/include/c++/4.1.3/cstring" 3



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




# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 34 "/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)));
# 94 "/usr/include/string.h" 3 4
extern void *memchr (__const void *__s, int __c, size_t __n)
      throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


# 108 "/usr/include/string.h" 3 4
extern void *rawmemchr (__const void *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 119 "/usr/include/string.h" 3 4
extern void *memrchr (__const void *__s, int __c, size_t __n)
      throw () __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)));

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

# 233 "/usr/include/string.h" 3 4
extern char *strchr (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 260 "/usr/include/string.h" 3 4
extern char *strrchr (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


# 274 "/usr/include/string.h" 3 4
extern char *strchrnul (__const char *__s, int __c)
     throw () __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)));
# 312 "/usr/include/string.h" 3 4
extern char *strpbrk (__const char *__s, __const char *__accept)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 340 "/usr/include/string.h" 3 4
extern char *strstr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));




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)));
# 371 "/usr/include/string.h" 3 4
extern char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));







extern void *memmem (__const void *__haystack, size_t __haystacklen,
       __const void *__needle, size_t __needlelen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));



extern void *__mempcpy (void *__restrict __dest,
   __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        __const void *__restrict __src, size_t __n)
     throw () __attribute__ ((__nonnull__ (1, 2)));





extern size_t strlen (__const char *__s)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern size_t strnlen (__const char *__string, size_t __maxlen)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));





extern char *strerror (int __errnum) throw ();

# 436 "/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)));
# 487 "/usr/include/string.h" 3 4
extern char *index (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 515 "/usr/include/string.h" 3 4
extern char *rindex (__const char *__s, int __c)
     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




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)));
# 604 "/usr/include/string.h" 3 4
extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1)));
# 644 "/usr/include/string.h" 3 4
}
# 53 "/usr/include/c++/4.1.3/cstring" 2 3
# 78 "/usr/include/c++/4.1.3/cstring" 3
namespace std
{
  using ::memcpy;
  using ::memmove;
  using ::strcpy;
  using ::strncpy;
  using ::strcat;
  using ::strncat;
  using ::memcmp;
  using ::strcmp;
  using ::strcoll;
  using ::strncmp;
  using ::strxfrm;
  using ::strcspn;
  using ::strspn;
  using ::strtok;
  using ::memset;
  using ::strerror;
  using ::strlen;

  using ::memchr;

  inline void*
  memchr(void* __p, int __c, size_t __n)
  { return memchr(const_cast<const void*>(__p), __c, __n); }

  using ::strchr;

  inline char*
  strchr(char* __s1, int __n)
  { return __builtin_strchr(const_cast<const char*>(__s1), __n); }

  using ::strpbrk;

  inline char*
  strpbrk(char* __s1, const char* __s2)
  { return __builtin_strpbrk(const_cast<const char*>(__s1), __s2); }

  using ::strrchr;

  inline char*
  strrchr(char* __s1, int __n)
  { return __builtin_strrchr(const_cast<const char*>(__s1), __n); }

  using ::strstr;

  inline char*
  strstr(char* __s1, const char* __s2)
  { return __builtin_strstr(const_cast<const char*>(__s1), __s2); }
}
# 42 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/c++/4.1.3/cstdio" 1 3
# 48 "/usr/include/c++/4.1.3/cstdio" 3
       
# 49 "/usr/include/c++/4.1.3/cstdio" 3
# 98 "/usr/include/c++/4.1.3/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;
}
# 154 "/usr/include/c++/4.1.3/cstdio" 3
namespace __gnu_cxx
{
# 169 "/usr/include/c++/4.1.3/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;
}
# 43 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/c++/4.1.3/clocale" 1 3
# 48 "/usr/include/c++/4.1.3/clocale" 3
       
# 49 "/usr/include/c++/4.1.3/clocale" 3

# 1 "/usr/include/locale.h" 1 3 4
# 29 "/usr/include/locale.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 30 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/bits/locale.h" 1 3 4
# 27 "/usr/include/bits/locale.h" 3 4
enum
{
  __LC_CTYPE = 0,
  __LC_NUMERIC = 1,
  __LC_TIME = 2,
  __LC_COLLATE = 3,
  __LC_MONETARY = 4,
  __LC_MESSAGES = 5,
  __LC_ALL = 6,
  __LC_PAPER = 7,
  __LC_NAME = 8,
  __LC_ADDRESS = 9,
  __LC_TELEPHONE = 10,
  __LC_MEASUREMENT = 11,
  __LC_IDENTIFICATION = 12
};
# 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 ();







}
# 51 "/usr/include/c++/4.1.3/clocale" 2 3





namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 44 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/langinfo.h" 1 3 4
# 24 "/usr/include/langinfo.h" 3 4
# 1 "/usr/include/nl_types.h" 1 3 4
# 31 "/usr/include/nl_types.h" 3 4
extern "C" {


typedef void *nl_catd;


typedef int nl_item;





extern nl_catd catopen (__const char *__cat_name, int __flag) __attribute__ ((__nonnull__ (1)));



extern char *catgets (nl_catd __catalog, int __set, int __number,
        __const char *__string) throw () __attribute__ ((__nonnull__ (1)));


extern int catclose (nl_catd __catalog) throw () __attribute__ ((__nonnull__ (1)));

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

# 1 "/usr/include/bits/locale.h" 1 3 4
# 27 "/usr/include/langinfo.h" 2 3 4


extern "C" {
# 42 "/usr/include/langinfo.h" 3 4
enum
{



  ABDAY_1 = (((__LC_TIME) << 16) | (0)),

  ABDAY_2,

  ABDAY_3,

  ABDAY_4,

  ABDAY_5,

  ABDAY_6,

  ABDAY_7,



  DAY_1,

  DAY_2,

  DAY_3,

  DAY_4,

  DAY_5,

  DAY_6,

  DAY_7,



  ABMON_1,

  ABMON_2,

  ABMON_3,

  ABMON_4,

  ABMON_5,

  ABMON_6,

  ABMON_7,

  ABMON_8,

  ABMON_9,

  ABMON_10,

  ABMON_11,

  ABMON_12,



  MON_1,

  MON_2,

  MON_3,

  MON_4,

  MON_5,

  MON_6,

  MON_7,

  MON_8,

  MON_9,

  MON_10,

  MON_11,

  MON_12,


  AM_STR,

  PM_STR,


  D_T_FMT,

  D_FMT,

  T_FMT,

  T_FMT_AMPM,


  ERA,

  __ERA_YEAR,



  ERA_D_FMT,

  ALT_DIGITS,

  ERA_D_T_FMT,

  ERA_T_FMT,


  _NL_TIME_ERA_NUM_ENTRIES,
  _NL_TIME_ERA_ENTRIES,

  _NL_WABDAY_1,
  _NL_WABDAY_2,
  _NL_WABDAY_3,
  _NL_WABDAY_4,
  _NL_WABDAY_5,
  _NL_WABDAY_6,
  _NL_WABDAY_7,


  _NL_WDAY_1,
  _NL_WDAY_2,
  _NL_WDAY_3,
  _NL_WDAY_4,
  _NL_WDAY_5,
  _NL_WDAY_6,
  _NL_WDAY_7,


  _NL_WABMON_1,
  _NL_WABMON_2,
  _NL_WABMON_3,
  _NL_WABMON_4,
  _NL_WABMON_5,
  _NL_WABMON_6,
  _NL_WABMON_7,
  _NL_WABMON_8,
  _NL_WABMON_9,
  _NL_WABMON_10,
  _NL_WABMON_11,
  _NL_WABMON_12,


  _NL_WMON_1,
  _NL_WMON_2,
  _NL_WMON_3,
  _NL_WMON_4,
  _NL_WMON_5,
  _NL_WMON_6,
  _NL_WMON_7,
  _NL_WMON_8,
  _NL_WMON_9,
  _NL_WMON_10,
  _NL_WMON_11,
  _NL_WMON_12,

  _NL_WAM_STR,
  _NL_WPM_STR,

  _NL_WD_T_FMT,
  _NL_WD_FMT,
  _NL_WT_FMT,
  _NL_WT_FMT_AMPM,

  _NL_WERA_YEAR,
  _NL_WERA_D_FMT,
  _NL_WALT_DIGITS,
  _NL_WERA_D_T_FMT,
  _NL_WERA_T_FMT,

  _NL_TIME_WEEK_NDAYS,
  _NL_TIME_WEEK_1STDAY,
  _NL_TIME_WEEK_1STWEEK,
  _NL_TIME_FIRST_WEEKDAY,
  _NL_TIME_FIRST_WORKDAY,
  _NL_TIME_CAL_DIRECTION,
  _NL_TIME_TIMEZONE,

  _DATE_FMT,

  _NL_W_DATE_FMT,

  _NL_TIME_CODESET,

  _NL_NUM_LC_TIME,




  _NL_COLLATE_NRULES = (((__LC_COLLATE) << 16) | (0)),
  _NL_COLLATE_RULESETS,
  _NL_COLLATE_TABLEMB,
  _NL_COLLATE_WEIGHTMB,
  _NL_COLLATE_EXTRAMB,
  _NL_COLLATE_INDIRECTMB,
  _NL_COLLATE_GAP1,
  _NL_COLLATE_GAP2,
  _NL_COLLATE_GAP3,
  _NL_COLLATE_TABLEWC,
  _NL_COLLATE_WEIGHTWC,
  _NL_COLLATE_EXTRAWC,
  _NL_COLLATE_INDIRECTWC,
  _NL_COLLATE_SYMB_HASH_SIZEMB,
  _NL_COLLATE_SYMB_TABLEMB,
  _NL_COLLATE_SYMB_EXTRAMB,
  _NL_COLLATE_COLLSEQMB,
  _NL_COLLATE_COLLSEQWC,
  _NL_COLLATE_CODESET,
  _NL_NUM_LC_COLLATE,




  _NL_CTYPE_CLASS = (((__LC_CTYPE) << 16) | (0)),
  _NL_CTYPE_TOUPPER,
  _NL_CTYPE_GAP1,
  _NL_CTYPE_TOLOWER,
  _NL_CTYPE_GAP2,
  _NL_CTYPE_CLASS32,
  _NL_CTYPE_GAP3,
  _NL_CTYPE_GAP4,
  _NL_CTYPE_GAP5,
  _NL_CTYPE_GAP6,
  _NL_CTYPE_CLASS_NAMES,
  _NL_CTYPE_MAP_NAMES,
  _NL_CTYPE_WIDTH,
  _NL_CTYPE_MB_CUR_MAX,
  _NL_CTYPE_CODESET_NAME,
  CODESET = _NL_CTYPE_CODESET_NAME,

  _NL_CTYPE_TOUPPER32,
  _NL_CTYPE_TOLOWER32,
  _NL_CTYPE_CLASS_OFFSET,
  _NL_CTYPE_MAP_OFFSET,
  _NL_CTYPE_INDIGITS_MB_LEN,
  _NL_CTYPE_INDIGITS0_MB,
  _NL_CTYPE_INDIGITS1_MB,
  _NL_CTYPE_INDIGITS2_MB,
  _NL_CTYPE_INDIGITS3_MB,
  _NL_CTYPE_INDIGITS4_MB,
  _NL_CTYPE_INDIGITS5_MB,
  _NL_CTYPE_INDIGITS6_MB,
  _NL_CTYPE_INDIGITS7_MB,
  _NL_CTYPE_INDIGITS8_MB,
  _NL_CTYPE_INDIGITS9_MB,
  _NL_CTYPE_INDIGITS_WC_LEN,
  _NL_CTYPE_INDIGITS0_WC,
  _NL_CTYPE_INDIGITS1_WC,
  _NL_CTYPE_INDIGITS2_WC,
  _NL_CTYPE_INDIGITS3_WC,
  _NL_CTYPE_INDIGITS4_WC,
  _NL_CTYPE_INDIGITS5_WC,
  _NL_CTYPE_INDIGITS6_WC,
  _NL_CTYPE_INDIGITS7_WC,
  _NL_CTYPE_INDIGITS8_WC,
  _NL_CTYPE_INDIGITS9_WC,
  _NL_CTYPE_OUTDIGIT0_MB,
  _NL_CTYPE_OUTDIGIT1_MB,
  _NL_CTYPE_OUTDIGIT2_MB,
  _NL_CTYPE_OUTDIGIT3_MB,
  _NL_CTYPE_OUTDIGIT4_MB,
  _NL_CTYPE_OUTDIGIT5_MB,
  _NL_CTYPE_OUTDIGIT6_MB,
  _NL_CTYPE_OUTDIGIT7_MB,
  _NL_CTYPE_OUTDIGIT8_MB,
  _NL_CTYPE_OUTDIGIT9_MB,
  _NL_CTYPE_OUTDIGIT0_WC,
  _NL_CTYPE_OUTDIGIT1_WC,
  _NL_CTYPE_OUTDIGIT2_WC,
  _NL_CTYPE_OUTDIGIT3_WC,
  _NL_CTYPE_OUTDIGIT4_WC,
  _NL_CTYPE_OUTDIGIT5_WC,
  _NL_CTYPE_OUTDIGIT6_WC,
  _NL_CTYPE_OUTDIGIT7_WC,
  _NL_CTYPE_OUTDIGIT8_WC,
  _NL_CTYPE_OUTDIGIT9_WC,
  _NL_CTYPE_TRANSLIT_TAB_SIZE,
  _NL_CTYPE_TRANSLIT_FROM_IDX,
  _NL_CTYPE_TRANSLIT_FROM_TBL,
  _NL_CTYPE_TRANSLIT_TO_IDX,
  _NL_CTYPE_TRANSLIT_TO_TBL,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING_LEN,
  _NL_CTYPE_TRANSLIT_DEFAULT_MISSING,
  _NL_CTYPE_TRANSLIT_IGNORE_LEN,
  _NL_CTYPE_TRANSLIT_IGNORE,
  _NL_CTYPE_MAP_TO_NONASCII,
  _NL_CTYPE_NONASCII_CASE,
  _NL_CTYPE_EXTRA_MAP_1,
  _NL_CTYPE_EXTRA_MAP_2,
  _NL_CTYPE_EXTRA_MAP_3,
  _NL_CTYPE_EXTRA_MAP_4,
  _NL_CTYPE_EXTRA_MAP_5,
  _NL_CTYPE_EXTRA_MAP_6,
  _NL_CTYPE_EXTRA_MAP_7,
  _NL_CTYPE_EXTRA_MAP_8,
  _NL_CTYPE_EXTRA_MAP_9,
  _NL_CTYPE_EXTRA_MAP_10,
  _NL_CTYPE_EXTRA_MAP_11,
  _NL_CTYPE_EXTRA_MAP_12,
  _NL_CTYPE_EXTRA_MAP_13,
  _NL_CTYPE_EXTRA_MAP_14,
  _NL_NUM_LC_CTYPE,




  __INT_CURR_SYMBOL = (((__LC_MONETARY) << 16) | (0)),



  __CURRENCY_SYMBOL,



  __MON_DECIMAL_POINT,



  __MON_THOUSANDS_SEP,



  __MON_GROUPING,



  __POSITIVE_SIGN,



  __NEGATIVE_SIGN,



  __INT_FRAC_DIGITS,



  __FRAC_DIGITS,



  __P_CS_PRECEDES,



  __P_SEP_BY_SPACE,



  __N_CS_PRECEDES,



  __N_SEP_BY_SPACE,



  __P_SIGN_POSN,



  __N_SIGN_POSN,



  _NL_MONETARY_CRNCYSTR,

  __INT_P_CS_PRECEDES,



  __INT_P_SEP_BY_SPACE,



  __INT_N_CS_PRECEDES,



  __INT_N_SEP_BY_SPACE,



  __INT_P_SIGN_POSN,



  __INT_N_SIGN_POSN,



  _NL_MONETARY_DUO_INT_CURR_SYMBOL,
  _NL_MONETARY_DUO_CURRENCY_SYMBOL,
  _NL_MONETARY_DUO_INT_FRAC_DIGITS,
  _NL_MONETARY_DUO_FRAC_DIGITS,
  _NL_MONETARY_DUO_P_CS_PRECEDES,
  _NL_MONETARY_DUO_P_SEP_BY_SPACE,
  _NL_MONETARY_DUO_N_CS_PRECEDES,
  _NL_MONETARY_DUO_N_SEP_BY_SPACE,
  _NL_MONETARY_DUO_INT_P_CS_PRECEDES,
  _NL_MONETARY_DUO_INT_P_SEP_BY_SPACE,
  _NL_MONETARY_DUO_INT_N_CS_PRECEDES,
  _NL_MONETARY_DUO_INT_N_SEP_BY_SPACE,
  _NL_MONETARY_DUO_P_SIGN_POSN,
  _NL_MONETARY_DUO_N_SIGN_POSN,
  _NL_MONETARY_DUO_INT_P_SIGN_POSN,
  _NL_MONETARY_DUO_INT_N_SIGN_POSN,
  _NL_MONETARY_UNO_VALID_FROM,
  _NL_MONETARY_UNO_VALID_TO,
  _NL_MONETARY_DUO_VALID_FROM,
  _NL_MONETARY_DUO_VALID_TO,
  _NL_MONETARY_CONVERSION_RATE,
  _NL_MONETARY_DECIMAL_POINT_WC,
  _NL_MONETARY_THOUSANDS_SEP_WC,
  _NL_MONETARY_CODESET,
  _NL_NUM_LC_MONETARY,



  __DECIMAL_POINT = (((__LC_NUMERIC) << 16) | (0)),



  RADIXCHAR = __DECIMAL_POINT,

  __THOUSANDS_SEP,



  THOUSEP = __THOUSANDS_SEP,

  __GROUPING,



  _NL_NUMERIC_DECIMAL_POINT_WC,
  _NL_NUMERIC_THOUSANDS_SEP_WC,
  _NL_NUMERIC_CODESET,
  _NL_NUM_LC_NUMERIC,

  __YESEXPR = (((__LC_MESSAGES) << 16) | (0)),

  __NOEXPR,

  __YESSTR,



  __NOSTR,



  _NL_MESSAGES_CODESET,
  _NL_NUM_LC_MESSAGES,

  _NL_PAPER_HEIGHT = (((__LC_PAPER) << 16) | (0)),
  _NL_PAPER_WIDTH,
  _NL_PAPER_CODESET,
  _NL_NUM_LC_PAPER,

  _NL_NAME_NAME_FMT = (((__LC_NAME) << 16) | (0)),
  _NL_NAME_NAME_GEN,
  _NL_NAME_NAME_MR,
  _NL_NAME_NAME_MRS,
  _NL_NAME_NAME_MISS,
  _NL_NAME_NAME_MS,
  _NL_NAME_CODESET,
  _NL_NUM_LC_NAME,

  _NL_ADDRESS_POSTAL_FMT = (((__LC_ADDRESS) << 16) | (0)),
  _NL_ADDRESS_COUNTRY_NAME,
  _NL_ADDRESS_COUNTRY_POST,
  _NL_ADDRESS_COUNTRY_AB2,
  _NL_ADDRESS_COUNTRY_AB3,
  _NL_ADDRESS_COUNTRY_CAR,
  _NL_ADDRESS_COUNTRY_NUM,
  _NL_ADDRESS_COUNTRY_ISBN,
  _NL_ADDRESS_LANG_NAME,
  _NL_ADDRESS_LANG_AB,
  _NL_ADDRESS_LANG_TERM,
  _NL_ADDRESS_LANG_LIB,
  _NL_ADDRESS_CODESET,
  _NL_NUM_LC_ADDRESS,

  _NL_TELEPHONE_TEL_INT_FMT = (((__LC_TELEPHONE) << 16) | (0)),
  _NL_TELEPHONE_TEL_DOM_FMT,
  _NL_TELEPHONE_INT_SELECT,
  _NL_TELEPHONE_INT_PREFIX,
  _NL_TELEPHONE_CODESET,
  _NL_NUM_LC_TELEPHONE,

  _NL_MEASUREMENT_MEASUREMENT = (((__LC_MEASUREMENT) << 16) | (0)),
  _NL_MEASUREMENT_CODESET,
  _NL_NUM_LC_MEASUREMENT,

  _NL_IDENTIFICATION_TITLE = (((__LC_IDENTIFICATION) << 16) | (0)),
  _NL_IDENTIFICATION_SOURCE,
  _NL_IDENTIFICATION_ADDRESS,
  _NL_IDENTIFICATION_CONTACT,
  _NL_IDENTIFICATION_EMAIL,
  _NL_IDENTIFICATION_TEL,
  _NL_IDENTIFICATION_FAX,
  _NL_IDENTIFICATION_LANGUAGE,
  _NL_IDENTIFICATION_TERRITORY,
  _NL_IDENTIFICATION_AUDIENCE,
  _NL_IDENTIFICATION_APPLICATION,
  _NL_IDENTIFICATION_ABBREVIATION,
  _NL_IDENTIFICATION_REVISION,
  _NL_IDENTIFICATION_DATE,
  _NL_IDENTIFICATION_CATEGORY,
  _NL_IDENTIFICATION_CODESET,
  _NL_NUM_LC_IDENTIFICATION,


  _NL_NUM
};
# 584 "/usr/include/langinfo.h" 3 4
extern char *nl_langinfo (nl_item __item) throw ();
# 595 "/usr/include/langinfo.h" 3 4
extern char *nl_langinfo_l (nl_item __item, __locale_t __l);


}
# 45 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/iconv.h" 1 3 4
# 24 "/usr/include/iconv.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 25 "/usr/include/iconv.h" 2 3 4


extern "C" {


typedef void *iconv_t;







extern iconv_t iconv_open (__const char *__tocode, __const char *__fromcode);




extern size_t iconv (iconv_t __cd, char **__restrict __inbuf,
       size_t *__restrict __inbytesleft,
       char **__restrict __outbuf,
       size_t *__restrict __outbytesleft);





extern int iconv_close (iconv_t __cd);

}
# 46 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 2 3
# 1 "/usr/include/libintl.h" 1 3 4
# 35 "/usr/include/libintl.h" 3 4
extern "C" {




extern char *gettext (__const char *__msgid)
     throw () __attribute__ ((__format_arg__ (1)));



extern char *dgettext (__const char *__domainname, __const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (__const char *__domainname, __const char *__msgid)
     throw () __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (__const char *__domainname,
   __const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (__const char *__domainname,
     __const char *__msgid, int __category)
     throw () __attribute__ ((__format_arg__ (2)));




extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
         unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (__const char *__domainname, __const char *__msgid1,
   __const char *__msgid2, unsigned long int __n)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));



extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
    __const char *__msgid2, unsigned long int __n,
    int __category)
     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (__const char *__domainname) throw ();



extern char *bindtextdomain (__const char *__domainname,
        __const char *__dirname) throw ();



extern char *bind_textdomain_codeset (__const char *__domainname,
          __const char *__codeset) throw ();
# 122 "/usr/include/libintl.h" 3 4
}
# 47 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 2 3






namespace __gnu_cxx
{
  extern "C" __typeof(uselocale) __uselocale;
}


namespace std
{
  typedef __locale_t __c_locale;





  template<typename _Tv>
    int
    __convert_from_v(char* __out,
       const int __size __attribute__ ((__unused__)),
       const char* __fmt,

       _Tv __v, const __c_locale& __cloc, int __prec)
    {
      __c_locale __old = __gnu_cxx::__uselocale(__cloc);
# 86 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++locale.h" 3
      const int __ret = std::snprintf(__out, __size, __fmt, __prec, __v);





      __gnu_cxx::__uselocale(__old);




      return __ret;
    }
}
# 46 "/usr/include/c++/4.1.3/iosfwd" 2 3
# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++io.h" 1 3
# 38 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++io.h" 3
# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr.h" 1 3
# 33 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 114 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr.h" 3
# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr-default.h" 1 3
# 43 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr-default.h" 3
# 1 "/usr/include/pthread.h" 1 3 4
# 25 "/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-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 30 "/usr/include/sched.h" 2 3 4


# 1 "/usr/include/time.h" 1 3 4
# 33 "/usr/include/sched.h" 2 3 4


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


}







struct __sched_param
  {
    int __sched_priority;
  };
# 113 "/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;
# 196 "/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 ();

}
# 36 "/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 ();
# 110 "/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 ();


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







# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 39 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 43 "/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;
# 180 "/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 ();
# 313 "/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__));
# 328 "/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 ();
# 390 "/usr/include/time.h" 3 4
extern int getdate_err;
# 399 "/usr/include/time.h" 3 4
extern struct tm *getdate (__const char *__string);
# 413 "/usr/include/time.h" 3 4
extern int getdate_r (__const char *__restrict __string,
        struct tm *__restrict __resbufp);


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


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

# 1 "/usr/include/bits/sigset.h" 1 3 4
# 34 "/usr/include/signal.h" 2 3 4
# 408 "/usr/include/signal.h" 3 4
}
# 30 "/usr/include/pthread.h" 2 3 4

# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 27 "/usr/include/bits/setjmp.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 32 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 33 "/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
};
# 117 "/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
};
# 149 "/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

};
# 184 "/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

};
# 222 "/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 ();







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_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)));
# 468 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 480 "/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__));
# 514 "/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); }
};
# 716 "/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_np (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));

extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
     throw () __attribute__ ((__nonnull__ (1)));
# 782 "/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)));
# 864 "/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)));
# 976 "/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)));
# 1020 "/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)));
# 1087 "/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)));
# 1121 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) throw ();
# 1135 "/usr/include/pthread.h" 3 4
}
# 44 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr-default.h" 2 3


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;
# 92 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr-default.h" 3
extern __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
extern __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
extern __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
extern __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
extern __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
extern __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
extern __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
extern __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
extern __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));


extern __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
extern __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
extern __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
extern __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
extern __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
# 149 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr
    = __extension__ (void *) &__gthrw_pthread_cancel;
  return __gthread_active_ptr != 0;
}
# 516 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr-default.h" 3
static inline int
__gthread_once (__gthread_once_t *once, void (*func) (void))
{
  if (__gthread_active_p ())
    return __gthrw_pthread_once (once, func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
  return __gthrw_pthread_key_create (key, dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t key)
{
  return __gthrw_pthread_key_delete (key);
}

static inline void *
__gthread_getspecific (__gthread_key_t key)
{
  return __gthrw_pthread_getspecific (key);
}

static inline int
__gthread_setspecific (__gthread_key_t key, const void *ptr)
{
  return __gthrw_pthread_setspecific (key, ptr);
}

static inline int
__gthread_mutex_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_unlock (__gthread_mutex_t *mutex)
{
  if (__gthread_active_p ())
    return __gthrw_pthread_mutex_unlock (mutex);
  else
    return 0;
}
# 598 "/usr/include/c++/4.1.3/x86_64-linux-gnu/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_unlock (__gthread_recursive_mutex_t *mutex)
{
  return __gthread_mutex_unlock (mutex);
}
# 115 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/gthr.h" 2 3







#pragma GCC visibility pop
# 39 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++io.h" 2 3

namespace std
{
  typedef __gthread_mutex_t __c_lock;


  typedef FILE __c_file;
}
# 47 "/usr/include/c++/4.1.3/iosfwd" 2 3
# 1 "/usr/include/c++/4.1.3/cctype" 1 3
# 48 "/usr/include/c++/4.1.3/cctype" 3
       
# 49 "/usr/include/c++/4.1.3/cctype" 3
# 68 "/usr/include/c++/4.1.3/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;
}
# 48 "/usr/include/c++/4.1.3/iosfwd" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stringfwd.h" 1 3
# 42 "/usr/include/c++/4.1.3/bits/stringfwd.h" 3
       
# 43 "/usr/include/c++/4.1.3/bits/stringfwd.h" 3



namespace std
{
  template<typename _Alloc>
    class allocator;

  template<class _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_string;

  template<> struct char_traits<char>;

  typedef basic_string<char> string;


  template<> struct char_traits<wchar_t>;

  typedef basic_string<wchar_t> wstring;

}
# 49 "/usr/include/c++/4.1.3/iosfwd" 2 3
# 1 "/usr/include/c++/4.1.3/bits/postypes.h" 1 3
# 44 "/usr/include/c++/4.1.3/bits/postypes.h" 3
       
# 45 "/usr/include/c++/4.1.3/bits/postypes.h" 3

# 1 "/usr/include/c++/4.1.3/cwchar" 1 3
# 48 "/usr/include/c++/4.1.3/cwchar" 3
       
# 49 "/usr/include/c++/4.1.3/cwchar" 3



# 1 "/usr/include/c++/4.1.3/ctime" 1 3
# 48 "/usr/include/c++/4.1.3/ctime" 3
       
# 49 "/usr/include/c++/4.1.3/ctime" 3
# 65 "/usr/include/c++/4.1.3/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;
}
# 53 "/usr/include/c++/4.1.3/cwchar" 2 3


# 1 "/usr/include/wchar.h" 1 3 4
# 40 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stdarg.h" 1 3 4
# 41 "/usr/include/wchar.h" 2 3 4
# 52 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 355 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 53 "/usr/include/wchar.h" 2 3 4
# 104 "/usr/include/wchar.h" 3 4


typedef __mbstate_t mbstate_t;



# 129 "/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 wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __attribute__ ((__pure__));
# 234 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
     throw () __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__));
# 263 "/usr/include/wchar.h" 3 4
extern wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept)
     throw () __attribute__ ((__pure__));
# 274 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __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__));

# 296 "/usr/include/wchar.h" 3 4
extern wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
     throw () __attribute__ ((__pure__));





extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
     throw () __attribute__ ((__pure__));




# 317 "/usr/include/wchar.h" 3 4
extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n)
     throw () __attribute__ ((__pure__));



extern int wmemcmp (__const wchar_t *__restrict __s1,
      __const wchar_t *__restrict __s2, size_t __n)
     throw () __attribute__ ((__pure__));


extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
    __const wchar_t *__restrict __s2, size_t __n) throw ();



extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
     throw ();


extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();





extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
     __const wchar_t *__restrict __s2, size_t __n)
     throw ();






extern wint_t btowc (int __c) throw ();



extern int wctob (wint_t __c) throw ();



extern int mbsinit (__const mbstate_t *__ps) throw () __attribute__ ((__pure__));



extern size_t mbrtowc (wchar_t *__restrict __pwc,
         __const char *__restrict __s, size_t __n,
         mbstate_t *__p) throw ();


extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
         mbstate_t *__restrict __ps) throw ();


extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
   mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (__const char *__restrict __s, size_t __n,
        mbstate_t *__restrict __ps) throw ();

# 403 "/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 ();
# 528 "/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 *__dest, __const wchar_t *__src) throw ();



extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
     throw ();
# 578 "/usr/include/wchar.h" 3 4
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 () ;
# 678 "/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 () ;
# 734 "/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);

# 799 "/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);
# 825 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 835 "/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 ();
# 889 "/usr/include/wchar.h" 3 4
}
# 56 "/usr/include/c++/4.1.3/cwchar" 2 3
# 70 "/usr/include/c++/4.1.3/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 142 "/usr/include/c++/4.1.3/cwchar" 3
namespace std
{
  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;

  inline wchar_t*
  wcschr(wchar_t* __p, wchar_t __c)
  { return wcschr(const_cast<const wchar_t*>(__p), __c); }

  using ::wcspbrk;

  inline wchar_t*
  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }

  using ::wcsrchr;

  inline wchar_t*
  wcsrchr(wchar_t* __p, wchar_t __c)
  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }

  using ::wcsstr;

  inline wchar_t*
  wcsstr(wchar_t* __s1, const wchar_t* __s2)
  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }

  using ::wmemchr;

  inline wchar_t*
  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
}







namespace __gnu_cxx
{





  using ::wcstold;
# 259 "/usr/include/c++/4.1.3/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using __gnu_cxx::wcstold;
  using __gnu_cxx::wcstoll;
  using __gnu_cxx::wcstoull;
}
# 47 "/usr/include/c++/4.1.3/bits/postypes.h" 2 3





namespace std
{
# 72 "/usr/include/c++/4.1.3/bits/postypes.h" 3
  typedef int64_t streamoff;





  typedef ptrdiff_t streamsize;

  template<typename _StateT>
    class fpos;
# 94 "/usr/include/c++/4.1.3/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 116 "/usr/include/c++/4.1.3/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; }






      bool
      operator==(const fpos& __other) const
      { return _M_off == __other._M_off; }


      bool
      operator!=(const fpos& __other) const
      { return _M_off != __other._M_off; }





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





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;
}
# 50 "/usr/include/c++/4.1.3/iosfwd" 2 3
# 1 "/usr/include/c++/4.1.3/bits/functexcept.h" 1 3
# 41 "/usr/include/c++/4.1.3/bits/functexcept.h" 3
# 1 "/usr/include/c++/4.1.3/exception_defines.h" 1 3
# 42 "/usr/include/c++/4.1.3/bits/functexcept.h" 2 3

namespace std
{

  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__));
}
# 51 "/usr/include/c++/4.1.3/iosfwd" 2 3

namespace std
{
  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;



  class ios_base;
# 135 "/usr/include/c++/4.1.3/iosfwd" 3
  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;


}
# 44 "/usr/include/c++/4.1.3/ios" 2 3
# 1 "/usr/include/c++/4.1.3/exception" 1 3
# 40 "/usr/include/c++/4.1.3/exception" 3
#pragma GCC visibility push(default)

extern "C++" {

namespace std
{
# 54 "/usr/include/c++/4.1.3/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();
  };


  typedef void (*terminate_handler) ();

  typedef void (*unexpected_handler) ();


  terminate_handler set_terminate(terminate_handler) throw();


  void terminate() __attribute__ ((__noreturn__));


  unexpected_handler set_unexpected(unexpected_handler) throw();


  void unexpected() __attribute__ ((__noreturn__));
# 102 "/usr/include/c++/4.1.3/exception" 3
  bool uncaught_exception() throw();
}

namespace __gnu_cxx
{
# 117 "/usr/include/c++/4.1.3/exception" 3
  void __verbose_terminate_handler ();
}

}

#pragma GCC visibility pop
# 45 "/usr/include/c++/4.1.3/ios" 2 3
# 1 "/usr/include/c++/4.1.3/bits/char_traits.h" 1 3
# 43 "/usr/include/c++/4.1.3/bits/char_traits.h" 3
       
# 44 "/usr/include/c++/4.1.3/bits/char_traits.h" 3


# 1 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 1 3
# 66 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
# 1 "/usr/include/c++/4.1.3/climits" 1 3
# 48 "/usr/include/c++/4.1.3/climits" 3
       
# 49 "/usr/include/c++/4.1.3/climits" 3

# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/limits.h" 1 3 4
# 11 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/limits.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 145 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 157 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 40 "/usr/include/bits/local_lim.h" 2 3 4
# 158 "/usr/include/bits/posix1_lim.h" 2 3 4
# 146 "/usr/include/limits.h" 2 3 4



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



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 154 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/syslimits.h" 2 3 4
# 12 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/limits.h" 2 3 4
# 51 "/usr/include/c++/4.1.3/climits" 2 3
# 67 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 2 3




# 1 "/usr/include/c++/4.1.3/bits/cpp_type_traits.h" 1 3
# 41 "/usr/include/c++/4.1.3/bits/cpp_type_traits.h" 3
       
# 42 "/usr/include/c++/4.1.3/bits/cpp_type_traits.h" 3
# 75 "/usr/include/c++/4.1.3/bits/cpp_type_traits.h" 3
namespace __gnu_internal
{
  typedef char __one;
  typedef char __two[2];

  template<typename _Tp>
  __one __test_type(int _Tp::*);
  template<typename _Tp>
  __two& __test_type(...);
}


namespace __gnu_cxx
{
  template<typename _Iterator, typename _Container>
    class __normal_iterator;
}

struct __true_type { };
struct __false_type { };

namespace std
{
  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, bool>
    struct __enable_if
    {
    };

  template<typename _Tp>
    struct __enable_if<_Tp, true>
    {
      typedef _Tp __type;
    };


  template<typename _Tp>
    struct __is_void
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<>
    struct __is_void<void>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_integer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };




  template<>
    struct __is_integer<bool>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<signed char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned char>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<>
    struct __is_integer<wchar_t>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };


  template<>
    struct __is_integer<short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned short>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned int>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_floating
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };


  template<>
    struct __is_floating<float>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_floating<double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<>
    struct __is_floating<long double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_pointer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Tp>
    struct __is_pointer<_Tp*>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_normal_iterator
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

  template<typename _Iterator, typename _Container>
    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
             _Container> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };




  template<typename _Tp>
    struct __is_arithmetic
    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
    { };




  template<typename _Tp>
    struct __is_fundamental
    : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
    { };




  template<typename _Tp>
    struct __is_scalar
    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
    { };




  template<typename _Tp>
    struct __is_pod
    {
      enum
 {
   __value = (sizeof(__gnu_internal::__test_type<_Tp>(0))
       != sizeof(__gnu_internal::__one))
 };
    };




  template<typename _Tp>
    struct __is_empty
    {
    private:
      template<typename>
        struct __first { };
      template<typename _Up>
        struct __second
        : public _Up { };

    public:
      enum
 {
   __value = sizeof(__first<_Tp>) == sizeof(__second<_Tp>)
 };
    };

}
# 72 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_iterator_base_types.h" 1 3
# 67 "/usr/include/c++/4.1.3/bits/stl_iterator_base_types.h" 3
       
# 68 "/usr/include/c++/4.1.3/bits/stl_iterator_base_types.h" 3

namespace std
{
# 80 "/usr/include/c++/4.1.3/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 {};
# 104 "/usr/include/c++/4.1.3/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;
    };







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

}
# 73 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_iterator_base_funcs.h" 1 3
# 67 "/usr/include/c++/4.1.3/bits/stl_iterator_base_funcs.h" 3
       
# 68 "/usr/include/c++/4.1.3/bits/stl_iterator_base_funcs.h" 3
# 1 "/usr/include/c++/4.1.3/bits/concept_check.h" 1 3
# 38 "/usr/include/c++/4.1.3/bits/concept_check.h" 3
       
# 39 "/usr/include/c++/4.1.3/bits/concept_check.h" 3
# 69 "/usr/include/c++/4.1.3/bits/stl_iterator_base_funcs.h" 2 3

namespace std
{
  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.1.3/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;
    }
# 170 "/usr/include/c++/4.1.3/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    inline void
    advance(_InputIterator& __i, _Distance __n)
    {

      std::__advance(__i, __n, std::__iterator_category(__i));
    }
}
# 74 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_iterator.h" 1 3
# 70 "/usr/include/c++/4.1.3/bits/stl_iterator.h" 3
namespace std
{
# 91 "/usr/include/c++/4.1.3/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;

    public:
      typedef _Iterator iterator_type;
      typedef typename iterator_traits<_Iterator>::difference_type
              difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::pointer pointer;

    public:






      reverse_iterator() : current() { }




      explicit
      reverse_iterator(iterator_type __x) : current(__x) { }




      reverse_iterator(const reverse_iterator& __x)
      : current(__x.current) { }





      template<typename _Iter>
        reverse_iterator(const reverse_iterator<_Iter>& __x)
 : current(__x.base()) { }




      iterator_type
      base() const
      { return current; }






      reference
      operator*() const
      {
 _Iterator __tmp = current;
 return *--__tmp;
      }






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






      reverse_iterator&
      operator++()
      {
 --current;
 return *this;
      }






      reverse_iterator
      operator++(int)
      {
 reverse_iterator __tmp = *this;
 --current;
 return __tmp;
      }






      reverse_iterator&
      operator--()
      {
 ++current;
 return *this;
      }






      reverse_iterator
      operator--(int)
      {
 reverse_iterator __tmp = *this;
 ++current;
 return __tmp;
      }






      reverse_iterator
      operator+(difference_type __n) const
      { return reverse_iterator(current - __n); }






      reverse_iterator&
      operator+=(difference_type __n)
      {
 current -= __n;
 return *this;
      }






      reverse_iterator
      operator-(difference_type __n) const
      { return reverse_iterator(current + __n); }






      reverse_iterator&
      operator-=(difference_type __n)
      {
 current += __n;
 return *this;
      }






      reference
      operator[](difference_type __n) const
      { return *(*this + __n); }
    };
# 278 "/usr/include/c++/4.1.3/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(); }
# 382 "/usr/include/c++/4.1.3/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) { }
# 408 "/usr/include/c++/4.1.3/bits/stl_iterator.h" 3
      back_insert_iterator&
      operator=(typename _Container::const_reference __value)
      {
 container->push_back(__value);
 return *this;
      }


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


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


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


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


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


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


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


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


      insert_iterator&
      operator++(int)
      { return *this; }
    };
# 612 "/usr/include/c++/4.1.3/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
{







  using std::iterator_traits;
  using std::iterator;
  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    protected:
      _Iterator _M_current;

    public:
      typedef typename iterator_traits<_Iterator>::iterator_category
                                                             iterator_category;
      typedef typename iterator_traits<_Iterator>::value_type value_type;
      typedef typename iterator_traits<_Iterator>::difference_type
                                                             difference_type;
      typedef typename iterator_traits<_Iterator>::reference reference;
      typedef typename iterator_traits<_Iterator>::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 std::__enable_if<_Container,
     (std::__are_same<_Iter,
      typename _Container::pointer>::__value)
     >::__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; }
    };
# 728 "/usr/include/c++/4.1.3/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 __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); }
}
# 75 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 2 3

# 1 "/usr/include/c++/4.1.3/debug/debug.h" 1 3
# 77 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 2 3

namespace std
{
# 90 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _Tp>
    inline void
    swap(_Tp& __a, _Tp& __b)
    {

     

      _Tp __tmp = __a;
      __a = __b;
      __b = __tmp;
    }




  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);
        }
    };
# 140 "/usr/include/c++/4.1.3/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);
    }
# 182 "/usr/include/c++/4.1.3/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;
    }
# 204 "/usr/include/c++/4.1.3/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;
    }
# 226 "/usr/include/c++/4.1.3/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;
    }
# 246 "/usr/include/c++/4.1.3/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<bool, typename>
    struct __copy
    {
      template<typename _II, typename _OI>
        static _OI
        copy(_II __first, _II __last, _OI __result)
        {
   for (; __first != __last; ++__result, ++__first)
     *__result = *__first;
   return __result;
 }
    };

  template<bool _BoolType>
    struct __copy<_BoolType, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
        static _OI
        copy(_II __first, _II __last, _OI __result)
        {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = *__first;
       ++__first;
       ++__result;
     }
   return __result;
 }
    };

  template<>
    struct __copy<true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        copy(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   std::memmove(__result, __first, sizeof(_Tp) * (__last - __first));
   return __result + (__last - __first);
 }
    };

  template<typename _II, typename _OI>
    inline _OI
    __copy_aux(_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_scalar<_ValueTypeI>::__value
                      && __is_pointer<_II>::__value
                      && __is_pointer<_OI>::__value
        && __are_same<_ValueTypeI, _ValueTypeO>::__value);

      return std::__copy<__simple, _Category>::copy(__first, __last, __result);
    }

  template<bool, bool>
    struct __copy_normal
    {
      template<typename _II, typename _OI>
        static _OI
        copy_n(_II __first, _II __last, _OI __result)
        { return std::__copy_aux(__first, __last, __result); }
    };

  template<>
    struct __copy_normal<true, false>
    {
      template<typename _II, typename _OI>
        static _OI
        copy_n(_II __first, _II __last, _OI __result)
        { return std::__copy_aux(__first.base(), __last.base(), __result); }
    };

  template<>
    struct __copy_normal<false, true>
    {
      template<typename _II, typename _OI>
        static _OI
        copy_n(_II __first, _II __last, _OI __result)
        { return _OI(std::__copy_aux(__first, __last, __result.base())); }
    };

  template<>
    struct __copy_normal<true, true>
    {
      template<typename _II, typename _OI>
        static _OI
        copy_n(_II __first, _II __last, _OI __result)
        { return _OI(std::__copy_aux(__first.base(), __last.base(),
         __result.base())); }
    };
# 373 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

      ;

       const bool __in = __is_normal_iterator<_InputIterator>::__value;
       const bool __out = __is_normal_iterator<_OutputIterator>::__value;
       return std::__copy_normal<__in, __out>::copy_n(__first, __last,
            __result);
    }

  template<bool, typename>
    struct __copy_backward
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        copy_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
   while (__first != __last)
     *--__result = *--__last;
   return __result;
 }
    };

  template<bool _BoolType>
    struct __copy_backward<_BoolType, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        copy_b(_BI1 __first, _BI1 __last, _BI2 __result)
        {
   typename iterator_traits<_BI1>::difference_type __n;
   for (__n = __last - __first; __n > 0; --__n)
     *--__result = *--__last;
   return __result;
 }
    };

  template<>
    struct __copy_backward<true, random_access_iterator_tag>
    {
      template<typename _Tp>
        static _Tp*
        copy_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
        {
   const ptrdiff_t _Num = __last - __first;
   std::memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
   return __result - _Num;
 }
    };

  template<typename _BI1, typename _BI2>
    inline _BI2
    __copy_backward_aux(_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_scalar<_ValueType1>::__value
                      && __is_pointer<_BI1>::__value
                      && __is_pointer<_BI2>::__value
        && __are_same<_ValueType1, _ValueType2>::__value);

      return std::__copy_backward<__simple, _Category>::copy_b(__first, __last,
              __result);
    }

  template<bool, bool>
    struct __copy_backward_normal
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
        { return std::__copy_backward_aux(__first, __last, __result); }
    };

  template<>
    struct __copy_backward_normal<true, false>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
        { return std::__copy_backward_aux(__first.base(), __last.base(),
       __result); }
    };

  template<>
    struct __copy_backward_normal<false, true>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
        { return _BI2(std::__copy_backward_aux(__first, __last,
            __result.base())); }
    };

  template<>
    struct __copy_backward_normal<true, true>
    {
      template<typename _BI1, typename _BI2>
        static _BI2
        copy_b_n(_BI1 __first, _BI1 __last, _BI2 __result)
        { return _BI2(std::__copy_backward_aux(__first.base(), __last.base(),
            __result.base())); }
    };
# 502 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template <typename _BI1, typename _BI2>
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {

     
     
     


      ;

      const bool __bi1 = __is_normal_iterator<_BI1>::__value;
      const bool __bi2 = __is_normal_iterator<_BI2>::__value;
      return std::__copy_backward_normal<__bi1, __bi2>::copy_b_n(__first, __last,
         __result);
    }

  template<bool>
    struct __fill
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        fill(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __value)
        {
   for (; __first != __last; ++__first)
     *__first = __value;
 }
    };

  template<>
    struct __fill<true>
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        fill(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __value)
        {
   const _Tp __tmp = __value;
   for (; __first != __last; ++__first)
     *__first = __tmp;
 }
    };
# 558 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {

     

      ;

      const bool __scalar = __is_scalar<_Tp>::__value;
      std::__fill<__scalar>::fill(__first, __last, __value);
    }


  inline void
  fill(unsigned char* __first, unsigned char* __last, const unsigned char& __c)
  {
    ;
    const unsigned char __tmp = __c;
    std::memset(__first, __tmp, __last - __first);
  }

  inline void
  fill(signed char* __first, signed char* __last, const signed char& __c)
  {
    ;
    const signed char __tmp = __c;
    std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
  }

  inline void
  fill(char* __first, char* __last, const char& __c)
  {
    ;
    const char __tmp = __c;
    std::memset(__first, static_cast<unsigned char>(__tmp), __last - __first);
  }

  template<bool>
    struct __fill_n
    {
      template<typename _OutputIterator, typename _Size, typename _Tp>
        static _OutputIterator
        fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
        {
   for (; __n > 0; --__n, ++__first)
     *__first = __value;
   return __first;
 }
    };

  template<>
    struct __fill_n<true>
    {
      template<typename _OutputIterator, typename _Size, typename _Tp>
        static _OutputIterator
        fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
        {
   const _Tp __tmp = __value;
   for (; __n > 0; --__n, ++__first)
     *__first = __tmp;
   return __first;
 }
    };
# 634 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _OutputIterator, typename _Size, typename _Tp>
    _OutputIterator
    fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
    {

     

      const bool __scalar = __is_scalar<_Tp>::__value;
      return std::__fill_n<__scalar>::fill_n(__first, __n, __value);
    }

  template<typename _Size>
    inline unsigned char*
    fill_n(unsigned char* __first, _Size __n, const unsigned char& __c)
    {
      std::fill(__first, __first + __n, __c);
      return __first + __n;
    }

  template<typename _Size>
    inline signed char*
    fill_n(char* __first, _Size __n, const signed char& __c)
    {
      std::fill(__first, __first + __n, __c);
      return __first + __n;
    }

  template<typename _Size>
    inline char*
    fill_n(char* __first, _Size __n, const char& __c)
    {
      std::fill(__first, __first + __n, __c);
      return __first + __n;
    }
# 681 "/usr/include/c++/4.1.3/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);
    }
# 716 "/usr/include/c++/4.1.3/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 && __binary_pred(*__first1, *__first2))
        {
   ++__first1;
   ++__first2;
        }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 746 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    inline bool
    equal(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2)
    {

     
     
     


      ;

      for (; __first1 != __last1; ++__first1, ++__first2)
 if (!(*__first1 == *__first2))
   return false;
      return true;
    }
# 778 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    inline bool
    equal(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2,
   _BinaryPredicate __binary_pred)
    {

     
     
      ;

      for (; __first1 != __last1; ++__first1, ++__first2)
 if (!__binary_pred(*__first1, *__first2))
   return false;
      return true;
    }
# 810 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    bool
    lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2)
    {

     
     
     


     


      ;
      ;

      for (; __first1 != __last1 && __first2 != __last2;
    ++__first1, ++__first2)
 {
   if (*__first1 < *__first2)
     return true;
   if (*__first2 < *__first1)
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }
# 850 "/usr/include/c++/4.1.3/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    bool
    lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _Compare __comp)
    {

     
     
      ;
      ;

      for (; __first1 != __last1 && __first2 != __last2;
    ++__first1, ++__first2)
 {
   if (__comp(*__first1, *__first2))
     return true;
   if (__comp(*__first2, *__first1))
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }

  inline bool
  lexicographical_compare(const unsigned char* __first1,
     const unsigned char* __last1,
     const unsigned char* __first2,
     const unsigned char* __last2)
  {
    ;
    ;

    const size_t __len1 = __last1 - __first1;
    const size_t __len2 = __last2 - __first2;
    const int __result = std::memcmp(__first1, __first2,
         std::min(__len1, __len2));
    return __result != 0 ? __result < 0 : __len1 < __len2;
  }

  inline bool
  lexicographical_compare(const char* __first1, const char* __last1,
     const char* __first2, const char* __last2)
  {
    ;
    ;


    return std::lexicographical_compare((const signed char*) __first1,
     (const signed char*) __last1,
     (const signed char*) __first2,
     (const signed char*) __last2);






  }

}
# 47 "/usr/include/c++/4.1.3/bits/char_traits.h" 2 3


namespace __gnu_cxx
{
# 61 "/usr/include/c++/4.1.3/bits/char_traits.h" 3
  template <class _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;
    };
# 86 "/usr/include/c++/4.1.3/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 (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*>(std::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
{
# 224 "/usr/include/c++/4.1.3/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 memcmp(__s1, __s2, __n); }

      static size_t
      length(const char_type* __s)
      { return strlen(__s); }

      static const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      { return static_cast<const char_type*>(memchr(__s, __a, __n)); }

      static char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memmove(__s1, __s2, __n)); }

      static char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      { return static_cast<char_type*>(memcpy(__s1, __s2, __n)); }

      static char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      { return static_cast<char_type*>(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; }
  };


}
# 46 "/usr/include/c++/4.1.3/ios" 2 3

# 1 "/usr/include/c++/4.1.3/bits/localefwd.h" 1 3
# 43 "/usr/include/c++/4.1.3/bits/localefwd.h" 3
       
# 44 "/usr/include/c++/4.1.3/bits/localefwd.h" 3






namespace std
{

  class locale;


  template<typename _CharT>
    inline bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    inline bool
    isgraph(_CharT, const locale&);

  template<typename _CharT>
    inline _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    inline _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;
  class __enc_traits;
  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;

  template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw();

  template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc);

  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
}
# 48 "/usr/include/c++/4.1.3/ios" 2 3
# 1 "/usr/include/c++/4.1.3/bits/ios_base.h" 1 3
# 43 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
       
# 44 "/usr/include/c++/4.1.3/bits/ios_base.h" 3

# 1 "/usr/include/c++/4.1.3/bits/atomicity.h" 1 3
# 38 "/usr/include/c++/4.1.3/bits/atomicity.h" 3
# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/atomic_word.h" 1 3
# 33 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 39 "/usr/include/c++/4.1.3/bits/atomicity.h" 2 3

namespace __gnu_cxx
{
  _Atomic_word
  __attribute__ ((__unused__))
  __exchange_and_add(volatile _Atomic_word* __mem, int __val);

  void
  __attribute__ ((__unused__))
  __atomic_add(volatile _Atomic_word* __mem, int __val);
}
# 46 "/usr/include/c++/4.1.3/bits/ios_base.h" 2 3

# 1 "/usr/include/c++/4.1.3/bits/locale_classes.h" 1 3
# 43 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
       
# 44 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3



# 1 "/usr/include/c++/4.1.3/string" 1 3
# 42 "/usr/include/c++/4.1.3/string" 3
       
# 43 "/usr/include/c++/4.1.3/string" 3




# 1 "/usr/include/c++/4.1.3/memory" 1 3
# 51 "/usr/include/c++/4.1.3/memory" 3
       
# 52 "/usr/include/c++/4.1.3/memory" 3


# 1 "/usr/include/c++/4.1.3/bits/allocator.h" 1 3
# 52 "/usr/include/c++/4.1.3/bits/allocator.h" 3
# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++allocator.h" 1 3
# 34 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++allocator.h" 3
# 1 "/usr/include/c++/4.1.3/ext/new_allocator.h" 1 3
# 37 "/usr/include/c++/4.1.3/ext/new_allocator.h" 3
# 1 "/usr/include/c++/4.1.3/new" 1 3
# 44 "/usr/include/c++/4.1.3/new" 3
#pragma GCC visibility push(default)

extern "C++" {

namespace std
{





  class bad_alloc : public exception
  {
  public:
    bad_alloc() throw() { }


    virtual ~bad_alloc() throw();
  };

  struct nothrow_t { };
  extern const nothrow_t nothrow;


  typedef void (*new_handler)();

  new_handler set_new_handler(new_handler) throw();
}
# 84 "/usr/include/c++/4.1.3/new" 3
void* operator new(std::size_t) throw (std::bad_alloc);
void* operator new[](std::size_t) throw (std::bad_alloc);
void operator delete(void*) throw();
void operator delete[](void*) throw();
void* operator new(std::size_t, const std::nothrow_t&) throw();
void* operator new[](std::size_t, const std::nothrow_t&) throw();
void operator delete(void*, const std::nothrow_t&) throw();
void operator delete[](void*, const std::nothrow_t&) throw();


inline void* operator new(std::size_t, void* __p) throw() { return __p; }
inline void* operator new[](std::size_t, void* __p) throw() { return __p; }


inline void operator delete (void*, void*) throw() { }
inline void operator delete[](void*, void*) throw() { }

}

#pragma GCC visibility pop
# 38 "/usr/include/c++/4.1.3/ext/new_allocator.h" 2 3


namespace __gnu_cxx
{







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

      const_pointer
      address(const_reference __x) const { return &__x; }



      pointer
      allocate(size_type __n, const void* = 0)
      {
 if (__builtin_expect(__n > this->max_size(), false))
   std::__throw_bad_alloc();

 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
      }


      void
      deallocate(pointer __p, size_type)
      { ::operator delete(__p); }

      size_type
      max_size() const throw()
      { return size_t(-1) / sizeof(_Tp); }



      void
      construct(pointer __p, const _Tp& __val)
      { ::new(__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; }
}
# 35 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/c++allocator.h" 2 3
# 53 "/usr/include/c++/4.1.3/bits/allocator.h" 2 3

namespace std
{
  template<typename _Tp>
    class allocator;


  template<>
    class allocator<void>
    {
    public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef void* pointer;
      typedef const void* const_pointer;
      typedef void value_type;

      template<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };
    };







  template<typename _Tp>
    class allocator: public __gnu_cxx::new_allocator<_Tp>
    {
   public:
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Tp* pointer;
      typedef const _Tp* const_pointer;
      typedef _Tp& reference;
      typedef const _Tp& const_reference;
      typedef _Tp value_type;

      template<typename _Tp1>
        struct rebind
        { typedef allocator<_Tp1> other; };

      allocator() throw() { }

      allocator(const allocator& __a) throw()
      : __gnu_cxx::new_allocator<_Tp>(__a) { }

      template<typename _Tp1>
        allocator(const allocator<_Tp1>&) throw() { }

      ~allocator() throw() { }


    };

  template<typename _T1, typename _T2>
    inline bool
    operator==(const allocator<_T1>&, const allocator<_T2>&)
    { return true; }

  template<typename _T1, typename _T2>
    inline bool
    operator!=(const allocator<_T1>&, const allocator<_T2>&)
    { return false; }





  extern template class allocator<char>;
  extern template class allocator<wchar_t>;




}
# 55 "/usr/include/c++/4.1.3/memory" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_construct.h" 1 3
# 67 "/usr/include/c++/4.1.3/bits/stl_construct.h" 3
namespace std
{






  template<typename _T1, typename _T2>
    inline void
    _Construct(_T1* __p, const _T2& __value)
    {


      ::new(static_cast<void*>(__p)) _T1(__value);
    }







  template<typename _T1>
    inline void
    _Construct(_T1* __p)
    {


      ::new(static_cast<void*>(__p)) _T1();
    }






  template<typename _Tp>
    inline void
    _Destroy(_Tp* __pointer)
    { __pointer->~_Tp(); }
# 116 "/usr/include/c++/4.1.3/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    inline void
    __destroy_aux(_ForwardIterator __first, _ForwardIterator __last,
    __false_type)
    {
      for (; __first != __last; ++__first)
 std::_Destroy(&*__first);
    }
# 134 "/usr/include/c++/4.1.3/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    inline void
    __destroy_aux(_ForwardIterator, _ForwardIterator, __true_type)
    { }
# 146 "/usr/include/c++/4.1.3/bits/stl_construct.h" 3
  template<typename _ForwardIterator>
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;
      typedef typename std::__is_scalar<_Value_type>::__type
                _Has_trivial_destructor;

      std::__destroy_aux(__first, __last, _Has_trivial_destructor());
    }
# 166 "/usr/include/c++/4.1.3/bits/stl_construct.h" 3
  template <typename _Tp> class allocator;

  template<typename _ForwardIterator, typename _Allocator>
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator __alloc)
    {
      for (; __first != __last; ++__first)
 __alloc.destroy(&*__first);
    }

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


}
# 56 "/usr/include/c++/4.1.3/memory" 2 3

# 1 "/usr/include/c++/4.1.3/bits/stl_uninitialized.h" 1 3
# 66 "/usr/include/c++/4.1.3/bits/stl_uninitialized.h" 3
namespace std
{

  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result,
        __true_type)
    { return std::copy(__first, __last, __result); }

  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_aux(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result,
        __false_type)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __first != __last; ++__first, ++__cur)
     std::_Construct(&*__cur, *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur);
   throw;
 }
    }
# 105 "/usr/include/c++/4.1.3/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type _ValueType;
      typedef typename std::__is_scalar<_ValueType>::__type _Is_POD;
      return std::__uninitialized_copy_aux(__first, __last, __result,
        _Is_POD());
    }

  inline char*
  uninitialized_copy(const char* __first, const char* __last, char* __result)
  {
    std::memmove(__result, __first, __last - __first);
    return __result + (__last - __first);
  }

  inline wchar_t*
  uninitialized_copy(const wchar_t* __first, const wchar_t* __last,
       wchar_t* __result)
  {
    std::memmove(__result, __first, sizeof(wchar_t) * (__last - __first));
    return __result + (__last - __first);
  }



  template<typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_fill_aux(_ForwardIterator __first,
        _ForwardIterator __last,
        const _Tp& __x, __true_type)
    { std::fill(__first, __last, __x); }

  template<typename _ForwardIterator, typename _Tp>
    void
    __uninitialized_fill_aux(_ForwardIterator __first, _ForwardIterator __last,
        const _Tp& __x, __false_type)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __cur != __last; ++__cur)
     std::_Construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur);
   throw;
 }
    }
# 167 "/usr/include/c++/4.1.3/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;
      typedef typename std::__is_scalar<_ValueType>::__type _Is_POD;
      std::__uninitialized_fill_aux(__first, __last, __x, _Is_POD());
    }



  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline void
    __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
          const _Tp& __x, __true_type)
    { std::fill_n(__first, __n, __x); }

  template<typename _ForwardIterator, typename _Size, typename _Tp>
    void
    __uninitialized_fill_n_aux(_ForwardIterator __first, _Size __n,
          const _Tp& __x, __false_type)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __n > 0; --__n, ++__cur)
     std::_Construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur);
   throw;
 }
    }
# 212 "/usr/include/c++/4.1.3/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;
      typedef typename std::__is_scalar<_ValueType>::__type _Is_POD;
      std::__uninitialized_fill_n_aux(__first, __n, __x, _Is_POD());
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result,
      _Allocator __alloc)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __first != __last; ++__first, ++__cur)
     __alloc.construct(&*__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 _ForwardIterator, typename _Tp, typename _Allocator>
    void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, _Allocator __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __cur != __last; ++__cur)
     __alloc.construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
    inline void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, allocator<_Tp2>)
    {
      std::uninitialized_fill(__first, __last, __x);
    }

  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Allocator>
    void
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x,
        _Allocator __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   for (; __n > 0; --__n, ++__cur)
     __alloc.construct(&*__cur, __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }

  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Tp2>
    void
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x,
        allocator<_Tp2>)
    {
      std::uninitialized_fill_n(__first, __n, __x);
    }
# 323 "/usr/include/c++/4.1.3/bits/stl_uninitialized.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_copy_copy(_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_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_copy(_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_copy_a(__first, __last, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
    typename _Allocator>
    inline void
    __uninitialized_copy_fill(_InputIterator __first1, _InputIterator __last1,
         _ForwardIterator __first2,
         _ForwardIterator __last2, const _Tp& __x,
         _Allocator __alloc)
    {
      _ForwardIterator __mid2 = std::__uninitialized_copy_a(__first1, __last1,
           __first2,
           __alloc);
      try
 {
   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__first2, __mid2, __alloc);
   throw;
 }
    }

}
# 58 "/usr/include/c++/4.1.3/memory" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_raw_storage_iter.h" 1 3
# 64 "/usr/include/c++/4.1.3/bits/stl_raw_storage_iter.h" 3
namespace std
{




  template <class _ForwardIterator, class _Tp>
    class raw_storage_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _ForwardIterator _M_iter;

    public:
      explicit
      raw_storage_iterator(_ForwardIterator __x)
      : _M_iter(__x) {}

      raw_storage_iterator&
      operator*() { return *this; }

      raw_storage_iterator&
      operator=(const _Tp& __element)
      {
 std::_Construct(&*_M_iter, __element);
 return *this;
      }

      raw_storage_iterator<_ForwardIterator, _Tp>&
      operator++()
      {
 ++_M_iter;
 return *this;
      }

      raw_storage_iterator<_ForwardIterator, _Tp>
      operator++(int)
      {
 raw_storage_iterator<_ForwardIterator, _Tp> __tmp = *this;
 ++_M_iter;
 return __tmp;
      }
    };
}
# 59 "/usr/include/c++/4.1.3/memory" 2 3

# 1 "/usr/include/c++/4.1.3/limits" 1 3
# 45 "/usr/include/c++/4.1.3/limits" 3
       
# 46 "/usr/include/c++/4.1.3/limits" 3
# 149 "/usr/include/c++/4.1.3/limits" 3
namespace std
{





  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.1.3/limits" 3
  struct __numeric_limits_base
  {


    static const bool is_specialized = false;




    static const int digits = 0;

    static const int digits10 = 0;

    static const bool is_signed = false;





    static const bool is_integer = false;




    static const bool is_exact = false;


    static const int radix = 0;



    static const int min_exponent = 0;


    static const int min_exponent10 = 0;



    static const int max_exponent = 0;


    static const int max_exponent10 = 0;


    static const bool has_infinity = false;


    static const bool has_quiet_NaN = false;


    static const bool has_signaling_NaN = false;

    static const float_denorm_style has_denorm = denorm_absent;


    static const bool has_denorm_loss = false;



    static const bool is_iec559 = false;



    static const bool is_bounded = false;




    static const bool is_modulo = false;


    static const bool traps = false;

    static const bool tinyness_before = false;



    static const float_round_style round_style = round_toward_zero;
  };
# 284 "/usr/include/c++/4.1.3/limits" 3
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {


      static _Tp min() throw() { return static_cast<_Tp>(0); }

      static _Tp max() throw() { return static_cast<_Tp>(0); }


      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }

      static _Tp round_error() throw() { return static_cast<_Tp>(0); }

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

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


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



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





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

      static bool min() throw()
      { return false; }
      static bool max() throw()
      { return true; }

      static const int digits = 1;
      static const int digits10 = 0;
      static const bool is_signed = false;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static bool epsilon() throw()
      { return false; }
      static bool round_error() throw()
      { return false; }

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

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

      static bool infinity() throw()
      { return false; }
      static bool quiet_NaN() throw()
      { return false; }
      static bool signaling_NaN() throw()
      { return false; }
      static bool denorm_min() throw()
      { return false; }

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




      static const bool traps = 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 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
      static char max() throw()
      { return (((char)(-1) < 0) ? ((char)1 << (sizeof(char) * 8 - ((char)(-1) < 0))) - 1 : ~(char)0); }

      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136);
      static const bool is_signed = ((char)(-1) < 0);
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static char epsilon() throw()
      { return 0; }
      static char round_error() throw()
      { return 0; }

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

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

      static char infinity() throw()
      { return char(); }
      static char quiet_NaN() throw()
      { return char(); }
      static char signaling_NaN() throw()
      { return char(); }
      static char denorm_min() throw()
      { return static_cast<char>(0); }

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

      static const bool traps = 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)) * 643 / 2136);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static signed char epsilon() throw()
      { return 0; }
      static signed char round_error() throw()
      { return 0; }

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

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

      static signed char infinity() throw()
      { return static_cast<signed char>(0); }
      static signed char quiet_NaN() throw()
      { return static_cast<signed char>(0); }
      static signed char signaling_NaN() throw()
      { return static_cast<signed char>(0); }
      static signed char denorm_min() throw()
      { return static_cast<signed char>(0); }

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

      static const bool traps = 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)) * 643 / 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 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
      static wchar_t max() throw()
      { return (((wchar_t)(-1) < 0) ? ((wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0))) - 1 : ~(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)) * 643 / 2136);
      static const bool is_signed = ((wchar_t)(-1) < 0);
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static wchar_t epsilon() throw()
      { return 0; }
      static wchar_t round_error() throw()
      { return 0; }

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

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

      static wchar_t infinity() throw()
      { return wchar_t(); }
      static wchar_t quiet_NaN() throw()
      { return wchar_t(); }
      static wchar_t signaling_NaN() throw()
      { return wchar_t(); }
      static wchar_t denorm_min() throw()
      { return wchar_t(); }

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

      static const bool traps = true;
      static const bool tinyness_before = false;
      static const float_round_style round_style = round_toward_zero;
    };


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

      static short min() throw()
      { return -32767 - 1; }
      static short max() throw()
      { return 32767; }

      static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static short epsilon() throw()
      { return 0; }
      static short round_error() throw()
      { return 0; }

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

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

      static short infinity() throw()
      { return short(); }
      static short quiet_NaN() throw()
      { return short(); }
      static short signaling_NaN() throw()
      { return short(); }
      static short denorm_min() throw()
      { return short(); }

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

      static const bool traps = 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)) * 643 / 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)) * 643 / 2136);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static int epsilon() throw()
      { return 0; }
      static int round_error() throw()
      { return 0; }

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

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

      static int infinity() throw()
      { return static_cast<int>(0); }
      static int quiet_NaN() throw()
      { return static_cast<int>(0); }
      static int signaling_NaN() throw()
      { return static_cast<int>(0); }
      static int denorm_min() throw()
      { return static_cast<int>(0); }

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

      static const bool traps = 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)) * 643 / 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)) * 643 / 2136);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static long epsilon() throw()
      { return 0; }
      static long round_error() throw()
      { return 0; }

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

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

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

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

      static const bool traps = 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)) * 643 / 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)) * 643 / 2136);
      static const bool is_signed = true;
      static const bool is_integer = true;
      static const bool is_exact = true;
      static const int radix = 2;
      static long long epsilon() throw()
      { return 0; }
      static long long round_error() throw()
      { return 0; }

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

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

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

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

      static const bool traps = 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)) * 643 / 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<float>
    {
      static const bool is_specialized = true;

      static float min() throw()
      { return 1.17549435e-38F; }
      static float max() throw()
      { return 3.40282347e+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.19209290e-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.40129846e-45F) ? 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.40129846e-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 2.2250738585072014e-308; }
      static double max() throw()
      { return 1.7976931348623157e+308; }

      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 2.2204460492503131e-16; }
      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(4.9406564584124654e-324) ? 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 4.9406564584124654e-324; }

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





}
# 61 "/usr/include/c++/4.1.3/memory" 2 3

namespace std
{
# 72 "/usr/include/c++/4.1.3/memory" 3
  template<typename _Tp>
    pair<_Tp*, ptrdiff_t>
    __get_temporary_buffer(ptrdiff_t __len, _Tp*)
    {
      const ptrdiff_t __max = numeric_limits<ptrdiff_t>::max() / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
       nothrow));
   if (__tmp != 0)
     return pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len /= 2;
 }
      return pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
    }
# 108 "/usr/include/c++/4.1.3/memory" 3
  template<typename _Tp>
    inline pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len)
    { return std::__get_temporary_buffer(__len, static_cast<_Tp*>(0)); }
# 120 "/usr/include/c++/4.1.3/memory" 3
  template<typename _Tp>
    void
    return_temporary_buffer(_Tp* __p)
    { ::operator delete(__p, nothrow); }
# 132 "/usr/include/c++/4.1.3/memory" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    };
# 173 "/usr/include/c++/4.1.3/memory" 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) { }
# 199 "/usr/include/c++/4.1.3/memory" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 211 "/usr/include/c++/4.1.3/memory" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 222 "/usr/include/c++/4.1.3/memory" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 239 "/usr/include/c++/4.1.3/memory" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 259 "/usr/include/c++/4.1.3/memory" 3
      ~auto_ptr() { delete _M_ptr; }
# 269 "/usr/include/c++/4.1.3/memory" 3
      element_type&
      operator*() const throw()
      {
 ;
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 ;
 return _M_ptr;
      }
# 299 "/usr/include/c++/4.1.3/memory" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 313 "/usr/include/c++/4.1.3/memory" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 328 "/usr/include/c++/4.1.3/memory" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 349 "/usr/include/c++/4.1.3/memory" 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()); }
  };
}
# 48 "/usr/include/c++/4.1.3/string" 2 3



# 1 "/usr/include/c++/4.1.3/bits/stl_function.h" 1 3
# 64 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
namespace std
{
# 101 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _Arg, class _Result>
    struct unary_function
    {
      typedef _Arg argument_type;


      typedef _Result result_type;
    };




  template <class _Arg1, class _Arg2, class _Result>
    struct binary_function
    {
      typedef _Arg1 first_argument_type;


      typedef _Arg2 second_argument_type;
      typedef _Result result_type;
    };
# 133 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


  template <class _Tp>
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };


  template <class _Tp>
    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
    };


  template <class _Tp>
    struct divides : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
    };


  template <class _Tp>
    struct modulus : public binary_function<_Tp, _Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
    };


  template <class _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {
      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };
# 195 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


  template <class _Tp>
    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };


  template <class _Tp>
    struct greater : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
    };


  template <class _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };


  template <class _Tp>
    struct greater_equal : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
    };


  template <class _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };
# 256 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template <class _Tp>
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };


  template <class _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };
# 311 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _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 <class _Predicate>
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }


  template <class _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 <class _Predicate>
    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 391 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _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 <class _Operation, class _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 <class _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 <class _Operation, class _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));
    }
# 480 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _Arg, class _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 <class _Arg, class _Result>
    inline pointer_to_unary_function<_Arg, _Result>
    ptr_fun(_Result (*__x)(_Arg))
    { return pointer_to_unary_function<_Arg, _Result>(__x); }


  template <class _Arg1, class _Arg2, class _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 <class _Arg1, class _Arg2, class _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 <class _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 <class _Pair>
    struct _Select1st : public unary_function<_Pair,
           typename _Pair::first_type>
    {
      typename _Pair::first_type&
      operator()(_Pair& __x) const
      { return __x.first; }

      const typename _Pair::first_type&
      operator()(const _Pair& __x) const
      { return __x.first; }
    };

  template <class _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; }
    };
# 582 "/usr/include/c++/4.1.3/bits/stl_function.h" 3
  template <class _Ret, class _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 <class _Ret, class _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 <class _Ret, class _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 <class _Ret, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp>
    inline mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t<_Ret, _Tp>(__f); }

  template <class _Ret, class _Tp>
    inline const_mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_t<_Ret, _Tp>(__f); }

  template <class _Ret, class _Tp>
    inline mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)())
    { return mem_fun_ref_t<_Ret, _Tp>(__f); }

  template <class _Ret, class _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 <class _Ret, class _Tp, class _Arg>
    inline mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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 <class _Ret, class _Tp, class _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); }



}
# 52 "/usr/include/c++/4.1.3/string" 2 3
# 1 "/usr/include/c++/4.1.3/bits/basic_string.h" 1 3
# 43 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
       
# 44 "/usr/include/c++/4.1.3/bits/basic_string.h" 3




namespace std
{
# 109 "/usr/include/c++/4.1.3/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:
# 146 "/usr/include/c++/4.1.3/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;
# 171 "/usr/include/c++/4.1.3/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)
 {
   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(&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(&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); }

      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:







      inline
      basic_string();




      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);
# 448 "/usr/include/c++/4.1.3/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());







      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); }
# 503 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }






      iterator
      begin()
      {
 _M_leak();
 return iterator(_M_data());
      }





      const_iterator
      begin() const
      { return const_iterator(_M_data()); }





      iterator
      end()
      {
 _M_leak();
 return iterator(_M_data() + this->size());
      }





      const_iterator
      end() const
      { return const_iterator(_M_data() + this->size()); }






      reverse_iterator
      rbegin()
      { return reverse_iterator(this->end()); }






      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(this->end()); }






      reverse_iterator
      rend()
      { return reverse_iterator(this->begin()); }






      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(this->begin()); }

    public:



      size_type
      size() const
      { return _M_rep()->_M_length; }



      size_type
      length() const
      { return _M_rep()->_M_length; }


      size_type
      max_size() const
      { return _Rep::_S_max_size; }
# 614 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      void
      resize(size_type __n, _CharT __c);
# 627 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }





      size_type
      capacity() const
      { return _M_rep()->_M_capacity; }
# 656 "/usr/include/c++/4.1.3/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; }
# 684 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      const_reference
      operator[] (size_type __pos) const
      {
 ;
 return _M_data()[__pos];
      }
# 701 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      reference
      operator[](size_type __pos)
      {

 ;

 ;
 _M_leak();
 return _M_data()[__pos];
      }
# 722 "/usr/include/c++/4.1.3/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];
      }
# 741 "/usr/include/c++/4.1.3/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];
      }







      basic_string&
      operator+=(const basic_string& __str)
      { return this->append(__str); }






      basic_string&
      operator+=(const _CharT* __s)
      { return this->append(__s); }






      basic_string&
      operator+=(_CharT __c)
      {
 this->push_back(__c);
 return *this;
      }






      basic_string&
      append(const basic_string& __str);
# 801 "/usr/include/c++/4.1.3/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));
      }
# 833 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      append(size_type __n, _CharT __c);
# 844 "/usr/include/c++/4.1.3/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);
# 883 "/usr/include/c++/4.1.3/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)); }
# 899 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s, size_type __n);
# 911 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      assign(const _CharT* __s)
      {
 ;
 return this->assign(__s, traits_type::length(__s));
      }
# 927 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 939 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      template<class _InputIterator>
        basic_string&
        assign(_InputIterator __first, _InputIterator __last)
        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
# 956 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      void
      insert(iterator __p, size_type __n, _CharT __c)
      { this->replace(__p, __p, __n, __c); }
# 971 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      template<class _InputIterator>
        void
        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
        { this->replace(__p, __p, __beg, __end); }
# 987 "/usr/include/c++/4.1.3/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()); }
# 1009 "/usr/include/c++/4.1.3/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)); }
# 1032 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n);
# 1050 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
 ;
 return this->insert(__pos, __s, traits_type::length(__s));
      }
# 1073 "/usr/include/c++/4.1.3/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); }
# 1090 "/usr/include/c++/4.1.3/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 this->_M_ibegin() + __pos;
      }
# 1114 "/usr/include/c++/4.1.3/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;
      }
# 1130 "/usr/include/c++/4.1.3/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 _M_ibegin() + __pos;
      }
# 1150 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      iterator
      erase(iterator __first, iterator __last)
      {
 ;

        const size_type __pos = __first - _M_ibegin();
 _M_mutate(__pos, __last - __first, size_type(0));
 _M_rep()->_M_set_leaked();
 return _M_ibegin() + __pos;
      }
# 1177 "/usr/include/c++/4.1.3/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()); }
# 1199 "/usr/include/c++/4.1.3/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)); }
# 1223 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2);
# 1242 "/usr/include/c++/4.1.3/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));
      }
# 1265 "/usr/include/c++/4.1.3/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); }
# 1283 "/usr/include/c++/4.1.3/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()); }
# 1301 "/usr/include/c++/4.1.3/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);
      }
# 1322 "/usr/include/c++/4.1.3/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));
      }
# 1343 "/usr/include/c++/4.1.3/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);
      }
# 1365 "/usr/include/c++/4.1.3/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);
      }

    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 _InIterator>
        static _CharT*
        _S_construct_aux(_InIterator __beg, _InIterator __end,
    const _Alloc& __a, __true_type)
 { return _S_construct(static_cast<size_type>(__beg),
         static_cast<value_type>(__end), __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:
# 1496 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 1506 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      void
      swap(basic_string& __s);
# 1516 "/usr/include/c++/4.1.3/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; }
# 1548 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const;
# 1561 "/usr/include/c++/4.1.3/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()); }
# 1575 "/usr/include/c++/4.1.3/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));
      }
# 1592 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find(_CharT __c, size_type __pos = 0) const;
# 1605 "/usr/include/c++/4.1.3/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()); }
# 1620 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
# 1633 "/usr/include/c++/4.1.3/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));
      }
# 1650 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      rfind(_CharT __c, size_type __pos = npos) const;
# 1663 "/usr/include/c++/4.1.3/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()); }
# 1678 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1691 "/usr/include/c++/4.1.3/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));
      }
# 1710 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const
      { return this->find(__c, __pos); }
# 1724 "/usr/include/c++/4.1.3/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()); }
# 1739 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
# 1752 "/usr/include/c++/4.1.3/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));
      }
# 1771 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const
      { return this->rfind(__c, __pos); }
# 1785 "/usr/include/c++/4.1.3/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()); }
# 1800 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const;
# 1814 "/usr/include/c++/4.1.3/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));
      }
# 1831 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const;
# 1844 "/usr/include/c++/4.1.3/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()); }
# 1860 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const;
# 1873 "/usr/include/c++/4.1.3/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));
      }
# 1890 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const;
# 1905 "/usr/include/c++/4.1.3/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); }
# 1923 "/usr/include/c++/4.1.3/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 = __size - __osize;
 return __r;
      }
# 1953 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const;
# 1977 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2) const;
# 1995 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      int
      compare(const _CharT* __s) const;
# 2018 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
# 2043 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const;
  };

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string<_CharT, _Traits, _Alloc>::
    basic_string()

    : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
# 2064 "/usr/include/c++/4.1.3/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;
    }
# 2135 "/usr/include/c++/4.1.3/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 _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; }
# 2172 "/usr/include/c++/4.1.3/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 __rhs.compare(__lhs) != 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const _CharT* __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return __rhs.compare(__lhs) != 0; }







  template<typename _CharT, typename _Traits, typename _Alloc>
    inline bool
    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    { return __lhs.compare(__rhs) != 0; }
# 2209 "/usr/include/c++/4.1.3/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; }
# 2246 "/usr/include/c++/4.1.3/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; }
# 2283 "/usr/include/c++/4.1.3/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; }
# 2320 "/usr/include/c++/4.1.3/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; }
# 2357 "/usr/include/c++/4.1.3/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); }
# 2374 "/usr/include/c++/4.1.3/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);
# 2392 "/usr/include/c++/4.1.3/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const basic_string<_CharT, _Traits, _Alloc>& __str);
# 2410 "/usr/include/c++/4.1.3/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);
# 2427 "/usr/include/c++/4.1.3/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);

  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.1.3/string" 2 3


# 1 "/usr/include/c++/4.1.3/algorithm" 1 3
# 63 "/usr/include/c++/4.1.3/algorithm" 3
       
# 64 "/usr/include/c++/4.1.3/algorithm" 3




# 1 "/usr/include/c++/4.1.3/bits/stl_algo.h" 1 3
# 65 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
# 1 "/usr/include/c++/4.1.3/bits/stl_heap.h" 1 3
# 65 "/usr/include/c++/4.1.3/bits/stl_heap.h" 3
namespace std
{



  template<typename _RandomAccessIterator, typename _Distance>
    bool
    __is_heap(_RandomAccessIterator __first, _Distance __n)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__first[__parent] < __first[__child])
     return false;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return true;
    }

  template<typename _RandomAccessIterator, typename _Distance,
           typename _StrictWeakOrdering>
    bool
    __is_heap(_RandomAccessIterator __first, _StrictWeakOrdering __comp,
       _Distance __n)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__comp(__first[__parent], __first[__child]))
     return false;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return true;
    }

  template<typename _RandomAccessIterator>
    bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::__is_heap(__first, std::distance(__first, __last)); }

  template<typename _RandomAccessIterator, typename _StrictWeakOrdering>
    bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _StrictWeakOrdering __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;
    }
# 139 "/usr/include/c++/4.1.3/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;


     

     
      ;


      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), _ValueType(*(__last - 1)));
    }

  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;
    }
# 187 "/usr/include/c++/4.1.3/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;


     

      ;
      ;

      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), _ValueType(*(__last - 1)), __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 = 2 * __holeIndex + 2;
      while (__secondChild < __len)
 {
   if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
     __secondChild--;
   *(__first + __holeIndex) = *(__first + __secondChild);
   __holeIndex = __secondChild;
   __secondChild = 2 * (__secondChild + 1);
 }
      if (__secondChild == __len)
 {
   *(__first + __holeIndex) = *(__first + (__secondChild - 1));
   __holeIndex = __secondChild - 1;
 }
      std::__push_heap(__first, __holeIndex, __topIndex, __value);
    }

  template<typename _RandomAccessIterator, typename _Tp>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Tp __value)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      *__result = *__first;
      std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
    __value);
    }
# 251 "/usr/include/c++/4.1.3/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      std::__pop_heap(__first, __last - 1, __last - 1,
        _ValueType(*(__last - 1)));
    }

  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 = 2 * __holeIndex + 2;
      while (__secondChild < __len)
 {
   if (__comp(*(__first + __secondChild),
       *(__first + (__secondChild - 1))))
     __secondChild--;
   *(__first + __holeIndex) = *(__first + __secondChild);
   __holeIndex = __secondChild;
   __secondChild = 2 * (__secondChild + 1);
 }
      if (__secondChild == __len)
 {
   *(__first + __holeIndex) = *(__first + (__secondChild - 1));
   __holeIndex = __secondChild - 1;
 }
      std::__push_heap(__first, __holeIndex, __topIndex, __value, __comp);
    }

  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Tp __value, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      *__result = *__first;
      std::__adjust_heap(__first, _Distance(0), _Distance(__last - __first),
    __value, __comp);
    }
# 317 "/usr/include/c++/4.1.3/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {

     

      ;
      ;

      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      std::__pop_heap(__first, __last - 1, __last - 1,
        _ValueType(*(__last - 1)), __comp);
    }
# 342 "/usr/include/c++/4.1.3/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)
 {
   std::__adjust_heap(__first, __parent, __len,
        _ValueType(*(__first + __parent)));
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 382 "/usr/include/c++/4.1.3/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline 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)
 {
   std::__adjust_heap(__first, __parent, __len,
        _ValueType(*(__first + __parent)), __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 420 "/usr/include/c++/4.1.3/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {

     

     

      ;


      while (__last - __first > 1)
 std::pop_heap(__first, __last--);
    }
# 446 "/usr/include/c++/4.1.3/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {

     

      ;
      ;

      while (__last - __first > 1)
 std::pop_heap(__first, __last--, __comp);
    }

}
# 66 "/usr/include/c++/4.1.3/bits/stl_algo.h" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_tempbuf.h" 1 3
# 66 "/usr/include/c++/4.1.3/bits/stl_tempbuf.h" 3
namespace std
{







  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;

      void
      _M_initialize_buffer(const _Tp&, __true_type) { }

      void
      _M_initialize_buffer(const _Tp& val, __false_type)
      { std::uninitialized_fill_n(_M_buffer, _M_len, val); }

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

      typedef typename std::__is_scalar<_Tp>::__type _Trivial;

      try
 {
   pair<pointer, size_type> __p(get_temporary_buffer<
           value_type>(_M_original_len));
   _M_buffer = __p.first;
   _M_len = __p.second;
   if (_M_len > 0)
     _M_initialize_buffer(*__first, _Trivial());
 }
      catch(...)
 {
   std::return_temporary_buffer(_M_buffer);
   _M_buffer = 0;
   _M_len = 0;
   throw;
 }
    }
}
# 67 "/usr/include/c++/4.1.3/bits/stl_algo.h" 2 3




namespace std
{
# 85 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _Tp>
    inline const _Tp&
    __median(const _Tp& __a, const _Tp& __b, const _Tp& __c)
    {

     
      if (__a < __b)
 if (__b < __c)
   return __b;
 else if (__a < __c)
   return __c;
 else
   return __a;
      else if (__a < __c)
 return __a;
      else if (__b < __c)
 return __c;
      else
 return __b;
    }
# 119 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    inline const _Tp&
    __median(const _Tp& __a, const _Tp& __b, const _Tp& __c, _Compare __comp)
    {

     
      if (__comp(__a, __b))
 if (__comp(__b, __c))
   return __b;
 else if (__comp(__a, __c))
   return __c;
 else
   return __a;
      else if (__comp(__a, __c))
 return __a;
      else if (__comp(__b, __c))
 return __c;
      else
 return __b;
    }
# 151 "/usr/include/c++/4.1.3/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;
    }






  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 && !__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;
 }
    }
# 305 "/usr/include/c++/4.1.3/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));
    }
# 327 "/usr/include/c++/4.1.3/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));
    }
# 349 "/usr/include/c++/4.1.3/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;
    }
# 380 "/usr/include/c++/4.1.3/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;
    }
# 411 "/usr/include/c++/4.1.3/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;
    }
# 435 "/usr/include/c++/4.1.3/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;
    }
# 474 "/usr/include/c++/4.1.3/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 __tmp(__first2);
      ++__tmp;
      if (__tmp == __last2)
 return std::find(__first1, __last1, *__first2);


      _ForwardIterator2 __p1, __p;
      __p1 = __first2; ++__p1;
      _ForwardIterator1 __current = __first1;

      while (__first1 != __last1)
 {
   __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;
    }
# 545 "/usr/include/c++/4.1.3/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 __tmp(__first2);
      ++__tmp;
      if (__tmp == __last2)
 {
   while (__first1 != __last1 && !__predicate(*__first1, *__first2))
     ++__first1;
   return __first1;
 }


      _ForwardIterator2 __p1, __p;
      __p1 = __first2; ++__p1;
      _ForwardIterator1 __current = __first1;

      while (__first1 != __last1)
 {
   while (__first1 != __last1)
     {
       if (__predicate(*__first1, *__first2))
  break;
       ++__first1;
     }
   while (__first1 != __last1 && !__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;
    }
# 617 "/usr/include/c++/4.1.3/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;
    }
# 651 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _Integer, typename _Tp>
    _RandomAccessIter
    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
        _Integer __count, const _Tp& __val,
        std::random_access_iterator_tag)
    {

      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      const _DistanceType __pattSize = __count;

      if (__tailSize < __pattSize)
        return __last;

      const _DistanceType __skipOffset = __pattSize - 1;
      _RandomAccessIter __lookAhead = __first + __skipOffset;
      __tailSize -= __pattSize;

      while (1)
 {


   while (!(*__lookAhead == __val))
     {
       if (__tailSize < __pattSize)
  return __last;
       __lookAhead += __pattSize;
       __tailSize -= __pattSize;
     }
   _DistanceType __remainder = __skipOffset;
   for (_RandomAccessIter __backTrack = __lookAhead - 1;
        *__backTrack == __val; --__backTrack)
     {
       if (--__remainder == 0)
  return (__lookAhead - __skipOffset);
     }
   if (__remainder > __tailSize)
     return __last;
   __lookAhead += __remainder;
   __tailSize -= __remainder;
 }
    }
# 709 "/usr/include/c++/4.1.3/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));
    }
# 736 "/usr/include/c++/4.1.3/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 && !__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 && __binary_pred(*__i, __val))
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = ++__i;
   while (__first != __last && !__binary_pred(*__first, __val))
     ++__first;
 }
      return __last;
    }
# 776 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _RandomAccessIter, typename _Integer, typename _Tp,
    typename _BinaryPredicate>
    _RandomAccessIter
    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
        _Integer __count, const _Tp& __val,
        _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
    {

      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      const _DistanceType __pattSize = __count;

      if (__tailSize < __pattSize)
        return __last;

      const _DistanceType __skipOffset = __pattSize - 1;
      _RandomAccessIter __lookAhead = __first + __skipOffset;
      __tailSize -= __pattSize;

      while (1)
 {


   while (!__binary_pred(*__lookAhead, __val))
     {
       if (__tailSize < __pattSize)
  return __last;
       __lookAhead += __pattSize;
       __tailSize -= __pattSize;
     }
   _DistanceType __remainder = __skipOffset;
   for (_RandomAccessIter __backTrack = __lookAhead - 1;
        __binary_pred(*__backTrack, __val); --__backTrack)
     {
       if (--__remainder == 0)
  return (__lookAhead - __skipOffset);
     }
   if (__remainder > __tailSize)
     return __last;
   __lookAhead += __remainder;
   __tailSize -= __remainder;
 }
    }
# 837 "/usr/include/c++/4.1.3/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 && !__binary_pred(*__first, __val))
     ++__first;
   return __first;
 }
      return std::__search_n(__first, __last, __count, __val, __binary_pred,
        std::__iterator_category(__first));
    }
# 873 "/usr/include/c++/4.1.3/bits/stl_algo.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;
    }
# 911 "/usr/include/c++/4.1.3/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;
    }
# 946 "/usr/include/c++/4.1.3/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;
    }
# 978 "/usr/include/c++/4.1.3/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;
    }
# 1009 "/usr/include/c++/4.1.3/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;
    }
# 1042 "/usr/include/c++/4.1.3/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;
    }
# 1078 "/usr/include/c++/4.1.3/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;
    }
# 1112 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {

     
     

      ;

      for ( ; __first != __last; ++__first)
 *__first = __gen();
    }
# 1138 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _OutputIterator, typename _Size, typename _Generator>
    _OutputIterator
    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    {

     



      for ( ; __n > 0; --__n, ++__first)
 *__first = __gen();
      return __first;
    }
# 1165 "/usr/include/c++/4.1.3/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;
    }
# 1201 "/usr/include/c++/4.1.3/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 (!__pred(*__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 1240 "/usr/include/c++/4.1.3/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);
      _ForwardIterator __i = __first;
      return __first == __last ? __first
          : std::remove_copy(++__i, __last,
        __first, __value);
    }
# 1275 "/usr/include/c++/4.1.3/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);
      _ForwardIterator __i = __first;
      return __first == __last ? __first
          : std::remove_copy_if(++__i, __last,
           __first, __pred);
    }
# 1301 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    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;
    }
# 1326 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result,
    forward_iterator_tag)
    {

      *__result = *__first;
      while (++__first != __last)
 if (!(*__result == *__first))
   *++__result = *__first;
      return ++__result;
    }
# 1348 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result,
    _BinaryPredicate __binary_pred,
    output_iterator_tag)
    {

     



      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      *__result = __value;
      while (++__first != __last)
 if (!__binary_pred(__value, *__first))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }
# 1380 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result,
    _BinaryPredicate __binary_pred,
    forward_iterator_tag)
    {

     



      *__result = *__first;
      while (++__first != __last)
 if (!__binary_pred(*__result, *__first)) *++__result = *__first;
      return ++__result;
    }
# 1412 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {

     
     

     

      ;

      typedef typename iterator_traits<_OutputIterator>::iterator_category
 _IterType;

      if (__first == __last) return __result;
      return std::__unique_copy(__first, __last, __result, _IterType());
    }
# 1447 "/usr/include/c++/4.1.3/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)
    {

     
     

      ;

      typedef typename iterator_traits<_OutputIterator>::iterator_category
 _IterType;

      if (__first == __last) return __result;
      return std::__unique_copy(__first, __last, __result,
    __binary_pred, _IterType());
    }
# 1481 "/usr/include/c++/4.1.3/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;
    }
# 1520 "/usr/include/c++/4.1.3/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 (!__binary_pred(*__dest, *__first))
   *++__dest = *__first;
      return ++__dest;
    }
# 1554 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  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;
   }
    }
# 1576 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  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;
 }
    }
# 1603 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {

     

      ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1629 "/usr/include/c++/4.1.3/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;
    }
# 1657 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  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
 {
   swap(*__first, *__first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      __first2 = __middle;

      while (__first2 != __last)
 {
   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)
 {
   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;

      const _Distance __n = __last - __first;
      const _Distance __k = __middle - __first;
      const _Distance __l = __n - __k;

      if (__k == __l)
 {
   std::swap_ranges(__first, __middle, __middle);
   return;
 }

      const _Distance __d = __gcd(__n, __k);

      for (_Distance __i = 0; __i < __d; __i++)
 {
   _ValueType __tmp = *__first;
   _RandomAccessIterator __p = __first;

   if (__k < __l)
     {
       for (_Distance __j = 0; __j < __l / __d; __j++)
  {
    if (__p > __first + __l)
      {
        *__p = *(__p - __l);
        __p -= __l;
      }

    *__p = *(__p + __k);
    __p += __k;
  }
     }
   else
     {
       for (_Distance __j = 0; __j < __k / __d - 1; __j ++)
  {
    if (__p < __last - __k)
      {
        *__p = *(__p + __k);
        __p += __k;
      }
    *__p = * (__p - __l);
    __p -= __l;
  }
     }

   *__p = __tmp;
   ++__first;
 }
    }
# 1836 "/usr/include/c++/4.1.3/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());
    }
# 1869 "/usr/include/c++/4.1.3/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));
    }
# 1895 "/usr/include/c++/4.1.3/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)));
    }
# 1922 "/usr/include/c++/4.1.3/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));
    }







  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))
   {
     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 (!__pred(*__last))
       --__last;
     else
       break;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }
# 2016 "/usr/include/c++/4.1.3/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));
    }







  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
    _ForwardIterator
    __inplace_stable_partition(_ForwardIterator __first,
          _ForwardIterator __last,
          _Predicate __pred, _Distance __len)
    {
      if (__len == 1)
 return __pred(*__first) ? __last : __first;
      _ForwardIterator __middle = __first;
      std::advance(__middle, __len / 2);
      _ForwardIterator __begin = std::__inplace_stable_partition(__first,
         __middle,
         __pred,
         __len / 2);
      _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
              __pred,
              __len
              - __len / 2);
      std::rotate(__begin, __middle, __end);
      std::advance(__begin, std::distance(__middle, __end));
      return __begin;
    }






  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
    typename _Distance>
    _ForwardIterator
    __stable_partition_adaptive(_ForwardIterator __first,
    _ForwardIterator __last,
    _Predicate __pred, _Distance __len,
    _Pointer __buffer,
    _Distance __buffer_size)
    {
      if (__len <= __buffer_size)
 {
   _ForwardIterator __result1 = __first;
   _Pointer __result2 = __buffer;
   for ( ; __first != __last ; ++__first)
     if (__pred(*__first))
       {
  *__result1 = *__first;
  ++__result1;
       }
     else
       {
  *__result2 = *__first;
  ++__result2;
       }
   std::copy(__buffer, __result2, __result1);
   return __result1;
 }
      else
 {
   _ForwardIterator __middle = __first;
   std::advance(__middle, __len / 2);
   _ForwardIterator __begin =
     std::__stable_partition_adaptive(__first, __middle, __pred,
          __len / 2, __buffer,
          __buffer_size);
   _ForwardIterator __end =
     std::__stable_partition_adaptive(__middle, __last, __pred,
          __len - __len / 2,
          __buffer, __buffer_size);
   std::rotate(__begin, __middle, __end);
   std::advance(__begin, std::distance(__middle, __end));
   return __begin;
 }
    }
# 2127 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {

     

     

      ;

      if (__first == __last)
 return __first;
      else
 {
   typedef typename iterator_traits<_ForwardIterator>::value_type
     _ValueType;
   typedef typename iterator_traits<_ForwardIterator>::difference_type
     _DistanceType;

   _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
        __last);
 if (__buf.size() > 0)
   return
     std::__stable_partition_adaptive(__first, __last, __pred,
       _DistanceType(__buf.requested_size()),
       __buf.begin(), __buf.size());
 else
   return
     std::__inplace_stable_partition(__first, __last, __pred,
      _DistanceType(__buf.requested_size()));
 }
    }






  template<typename _RandomAccessIterator, typename _Tp>
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _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,
     _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;
 }
    }







  enum { _S_threshold = 16 };






  template<typename _RandomAccessIterator, typename _Tp>
    void
    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val)
    {
      _RandomAccessIterator __next = __last;
      --__next;
      while (__val < *__next)
 {
   *__last = *__next;
   __last = __next;
   --__next;
 }
      *__last = __val;
    }






  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
    void
    __unguarded_linear_insert(_RandomAccessIterator __last, _Tp __val,
         _Compare __comp)
    {
      _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)
 {
   typename iterator_traits<_RandomAccessIterator>::value_type
     __val = *__i;
   if (__val < *__first)
     {
       std::copy_backward(__first, __i, __i + 1);
       *__first = __val;
     }
   else
     std::__unguarded_linear_insert(__i, __val);
 }
    }






  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)
 {
   typename iterator_traits<_RandomAccessIterator>::value_type
     __val = *__i;
   if (__comp(__val, *__first))
     {
       std::copy_backward(__first, __i, __i + 1);
       *__first = __val;
     }
   else
     std::__unguarded_linear_insert(__i, __val, __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, _ValueType(*__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, _ValueType(*__i), __comp);
    }






  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 _Size>
    inline _Size
    __lg(_Size __n)
    {
      _Size __k;
      for (__k = 0; __n != 1; __n >>= 1)
 ++__k;
      return __k;
    }
# 2416 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      std::make_heap(__first, __middle);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (*__i < *__first)
   std::__pop_heap(__first, __middle, __i, _ValueType(*__i));
      std::sort_heap(__first, __middle);
    }
# 2457 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      std::make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(*__i, *__first))
   std::__pop_heap(__first, __middle, __i, _ValueType(*__i), __comp);
      std::sort_heap(__first, __middle, __comp);
    }
# 2499 "/usr/include/c++/4.1.3/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;
    }
# 2563 "/usr/include/c++/4.1.3/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, typename _Size>
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      while (__last - __first > int(_S_threshold))
 {
   if (__depth_limit == 0)
     {
       std::partial_sort(__first, __last, __last);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last
          - 1))));
   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)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;

      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(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last - 1),
        __comp)),
           __comp);
   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
   __last = __cut;
 }
    }
# 2698 "/usr/include/c++/4.1.3/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, __lg(__last - __first) * 2);
   std::__final_insertion_sort(__first, __last);
 }
    }
# 2732 "/usr/include/c++/4.1.3/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, __lg(__last - __first) * 2,
    __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }
# 2765 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;






     
     
     
      ;

      _DistanceType __len = std::distance(__first, __last);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (*__middle < __val)
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 2820 "/usr/include/c++/4.1.3/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);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(*__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 2867 "/usr/include/c++/4.1.3/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);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__val < *__middle)
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2919 "/usr/include/c++/4.1.3/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);
      _DistanceType __half;
      _ForwardIterator __middle;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__val, *__middle))
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }






  template<typename _BidirectionalIterator, typename _Distance>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2)
    {
      if (__len1 == 0 || __len2 == 0)
 return;
      if (__len1 + __len2 == 2)
 {
   if (*__middle < *__first)
     std::iter_swap(__first, __middle);
   return;
 }
      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut = std::lower_bound(__middle, __last, *__first_cut);
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut = std::upper_bound(__first, __middle, *__second_cut);
   __len11 = std::distance(__first, __first_cut);
 }
      std::rotate(__first_cut, __middle, __second_cut);
      _BidirectionalIterator __new_middle = __first_cut;
      std::advance(__new_middle, std::distance(__middle, __second_cut));
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22);
    }






  template<typename _BidirectionalIterator, typename _Distance,
    typename _Compare>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
                           _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2,
      _Compare __comp)
    {
      if (__len1 == 0 || __len2 == 0)
 return;
      if (__len1 + __len2 == 2)
 {
   if (__comp(*__middle, *__first))
     std::iter_swap(__first, __middle);
   return;
 }
      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut = std::lower_bound(__middle, __last, *__first_cut,
       __comp);
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut = std::upper_bound(__first, __middle, *__second_cut,
      __comp);
   __len11 = std::distance(__first, __first_cut);
 }
      std::rotate(__first_cut, __middle, __second_cut);
      _BidirectionalIterator __new_middle = __first_cut;
      std::advance(__new_middle, std::distance(__middle, __second_cut));
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22, __comp);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22, __comp);
    }






  template<typename _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);
    }
# 3117 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    _OutputIterator
    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));
    }
# 3175 "/usr/include/c++/4.1.3/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)
    {

     
     
     


     

     


      ;
      ;

      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::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::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::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::merge(__first, __first + __step_size,
   __first + __step_size, __last,
   __result,
   __comp);
    }

  enum { _S_chunk_size = 7 };

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

  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 _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3>
    _BidirectionalIterator3
    __merge_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result)
    {
      if (__first1 == __last1)
 return std::copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
 return std::copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true)
 {
   if (*__last2 < *__last1)
     {
       *--__result = *__last1;
       if (__first1 == __last1)
  return std::copy_backward(__first2, ++__last2, __result);
       --__last1;
     }
   else
     {
       *--__result = *__last2;
       if (__first2 == __last2)
  return std::copy_backward(__first1, ++__last1, __result);
       --__last2;
     }
 }
    }






  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3, typename _Compare>
    _BidirectionalIterator3
    __merge_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result,
       _Compare __comp)
    {
      if (__first1 == __last1)
 return std::copy_backward(__first2, __last2, __result);
      if (__first2 == __last2)
 return std::copy_backward(__first1, __last1, __result);
      --__last1;
      --__last2;
      while (true)
 {
   if (__comp(*__last2, *__last1))
     {
       *--__result = *__last1;
       if (__first1 == __last1)
  return std::copy_backward(__first2, ++__last2, __result);
       --__last1;
     }
   else
     {
       *--__result = *__last2;
       if (__first2 == __last2)
  return std::copy_backward(__first1, ++__last1, __result);
       --__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)
 {
   __buffer_end = std::copy(__middle, __last, __buffer);
   std::copy_backward(__first, __middle, __last);
   return std::copy(__buffer, __buffer_end, __first);
 }
      else if (__len1 <= __buffer_size)
 {
   __buffer_end = std::copy(__first, __middle, __buffer);
   std::copy(__middle, __last, __first);
   return std::copy_backward(__buffer, __buffer_end, __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::merge(__buffer, __buffer_end, __middle, __last, __first);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
   std::__merge_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::merge(__buffer, __buffer_end, __middle, __last, __first, __comp);
 }
      else if (__len2 <= __buffer_size)
 {
   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
   std::__merge_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);
 }
    }
# 3595 "/usr/include/c++/4.1.3/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()));
    }
# 3649 "/usr/include/c++/4.1.3/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 _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);
    }
# 3758 "/usr/include/c++/4.1.3/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()));
    }
# 3799 "/usr/include/c++/4.1.3/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);
    }
# 3840 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    void
    nth_element(_RandomAccessIterator __first,
  _RandomAccessIterator __nth,
  _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     
      ;
      ;

      while (__last - __first > 3)
 {
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last
          - 1))));
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last);
    }
# 3891 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    void
    nth_element(_RandomAccessIterator __first,
  _RandomAccessIterator __nth,
  _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


     

     

      ;
      ;

      while (__last - __first > 3)
 {
   _RandomAccessIterator __cut =
     std::__unguarded_partition(__first, __last,
           _ValueType(std::__median(*__first,
        *(__first
          + (__last
             - __first)
          / 2),
        *(__last - 1),
             __comp)), __comp);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last, __comp);
    }
# 3944 "/usr/include/c++/4.1.3/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);
      _DistanceType __half;
      _ForwardIterator __middle, __left, __right;

      while (__len > 0)
 {
   __half = __len >> 1;
   __middle = __first;
   std::advance(__middle, __half);
   if (*__middle < __val)
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__val < *__middle)
     __len = __half;
   else
     {
       __left = std::lower_bound(__first, __middle, __val);
       std::advance(__first, __len);
       __right = std::upper_bound(++__middle, __first, __val);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 4006 "/usr/include/c++/4.1.3/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);
      _DistanceType __half;
      _ForwardIterator __middle, __left, __right;

      while (__len > 0)
 {
   __half = __len >> 1;
   __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
     {
       __left = std::lower_bound(__first, __middle, __val, __comp);
       std::advance(__first, __len);
       __right = std::upper_bound(++__middle, __first, __val, __comp);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 4064 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val)
    {


     
     

     
      ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
      return __i != __last && !(__val < *__i);
    }
# 4096 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
                  const _Tp& __val, _Compare __comp)
    {

     
     

     

      ;

      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
      return __i != __last && !__comp(__val, *__i);
    }
# 4134 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {

     
     
     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first2 < *__first1)
   return false;
 else if(*__first1 < *__first2)
   ++__first1;
 else
   ++__first1, ++__first2;

      return __first2 == __last2;
    }
# 4180 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2, _Compare __comp)
    {

     
     
     


     


      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first2, *__first1))
   return false;
 else if(__comp(*__first1, *__first2))
   ++__first1;
 else
   ++__first1, ++__first2;

      return __first2 == __last2;
    }
# 4226 "/usr/include/c++/4.1.3/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)
    {

     
     
     

     


     

      ;
      ;

      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));
    }
# 4288 "/usr/include/c++/4.1.3/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)
    {

     
     
     


     

     


      ;
      ;

      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));
    }
# 4349 "/usr/include/c++/4.1.3/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)
    {

     
     
     

     


     

      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (*__first1 < *__first2)
   ++__first1;
 else if (*__first2 < *__first1)
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 4403 "/usr/include/c++/4.1.3/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)
    {

     
     
     


     

     


      ;
      ;

      while (__first1 != __last1 && __first2 != __last2)
 if (__comp(*__first1, *__first2))
   ++__first1;
 else if (__comp(*__first2, *__first1))
   ++__first2;
 else
   {
     *__result = *__first1;
     ++__first1;
     ++__first2;
     ++__result;
   }
      return __result;
    }
# 4457 "/usr/include/c++/4.1.3/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)
    {

     
     
     

     


     

      ;
      ;

      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);
    }
# 4515 "/usr/include/c++/4.1.3/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)
    {

     
     
     


     

     


      ;
      ;

      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);
    }
# 4569 "/usr/include/c++/4.1.3/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)
    {

     
     
     

     


     

      ;
      ;

      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));
    }
# 4630 "/usr/include/c++/4.1.3/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)
    {

     
     
     


     

     


      ;
      ;

      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));
    }
# 4683 "/usr/include/c++/4.1.3/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;
    }
# 4710 "/usr/include/c++/4.1.3/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;
    }







  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;
    }
# 4762 "/usr/include/c++/4.1.3/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;
    }
# 4797 "/usr/include/c++/4.1.3/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;
     }
 }
    }
# 4853 "/usr/include/c++/4.1.3/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 (!__comp(*__i, *--__j))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 4908 "/usr/include/c++/4.1.3/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;
     }
 }
    }
# 4964 "/usr/include/c++/4.1.3/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 (!__comp(*--__j, *__i))
  {}
       std::iter_swap(__i, __j);
       std::reverse(__ii, __last);
       return true;
     }
   if (__i == __first)
     {
       std::reverse(__first, __last);
       return false;
     }
 }
    }
# 5023 "/usr/include/c++/4.1.3/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;
    }
# 5059 "/usr/include/c++/4.1.3/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;
    }
# 5089 "/usr/include/c++/4.1.3/bits/stl_algo.h" 3
  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;
 }
    }
# 5239 "/usr/include/c++/4.1.3/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));
    }
# 5284 "/usr/include/c++/4.1.3/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);
    }

}
# 69 "/usr/include/c++/4.1.3/algorithm" 2 3
# 56 "/usr/include/c++/4.1.3/string" 2 3
# 1 "/usr/include/c++/4.1.3/bits/basic_string.tcc" 1 3
# 46 "/usr/include/c++/4.1.3/bits/basic_string.tcc" 3
       
# 47 "/usr/include/c++/4.1.3/bits/basic_string.tcc" 3

namespace std
{
  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 _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 (__builtin_expect(__is_null_pointer(__beg) && __beg != __end, 0))
   __throw_logic_error(("basic_string::_S_construct NULL not valid"));

 const size_type __dnew = static_cast<size_type>(std::distance(__beg,
              __end));

 _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
 try
   { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
 catch(...)
   {
     __r->_M_destroy(__a);
     throw;
   }
 __r->_M_set_length_and_sharable(__dnew);
 return __r->_M_refdata();
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    _CharT*
    basic_string<_CharT, _Traits, _Alloc>::
    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
    {

      if (__n == 0 && __a == _Alloc())
 return _S_empty_rep()._M_refdata();


      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
      if (__n)
 _M_assign(__r->_M_refdata(), __n, __c);

      __r->_M_set_length_and_sharable(__n);
      return __r->_M_refdata();
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str)
    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
       __str.get_allocator()),
    __str.get_allocator())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _Alloc& __a)
    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos, size_type __n)
    : _M_dataplus(_S_construct(__str._M_data()
          + __str._M_check(__pos,
      "basic_string::basic_string"),
          __str._M_data() + __str._M_limit(__pos, __n)
          + __pos, _Alloc()), _Alloc())
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const basic_string& __str, size_type __pos,
   size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__str._M_data()
          + __str._M_check(__pos,
      "basic_string::basic_string"),
          __str._M_data() + __str._M_limit(__pos, __n)
          + __pos, __a), __a)
    { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
    { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(const _CharT* __s, const _Alloc& __a)
    : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
          __s + npos, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
    : _M_dataplus(_S_construct(__n, __c, __a), __a)
    { }


  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
    basic_string<_CharT, _Traits, _Alloc>::
    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
    { }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    assign(const basic_string& __str)
    {
      if (_M_rep() != __str._M_rep())
 {

   const allocator_type __a = this->get_allocator();
   _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
   _M_rep()->_M_dispose(__a);
   _M_data(__tmp);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    assign(const _CharT* __s, size_type __n)
    {
      ;
      _M_check_length(this->size(), __n, "basic_string::assign");
      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
 return _M_replace_safe(size_type(0), this->size(), __s, __n);
      else
 {

   const size_type __pos = __s - _M_data();
   if (__pos >= __n)
     _M_copy(_M_data(), __s, __n);
   else if (__pos)
     _M_move(_M_data(), __s, __n);
   _M_rep()->_M_set_length_and_sharable(__n);
   return *this;
 }
     }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(size_type __n, _CharT __c)
    {
      if (__n)
 {
   _M_check_length(size_type(0), __n, "basic_string::append");
   const size_type __len = __n + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     this->reserve(__len);
   _M_assign(_M_data() + this->size(), __n, __c);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const _CharT* __s, size_type __n)
    {
      ;
      if (__n)
 {
   _M_check_length(size_type(0), __n, "basic_string::append");
   const size_type __len = __n + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     {
       if (_M_disjunct(__s))
  this->reserve(__len);
       else
  {
    const size_type __off = __s - _M_data();
    this->reserve(__len);
    __s = _M_data() + __off;
  }
     }
   _M_copy(_M_data() + this->size(), __s, __n);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const basic_string& __str)
    {
      const size_type __size = __str.size();
      if (__size)
 {
   const size_type __len = __size + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     this->reserve(__len);
   _M_copy(_M_data() + this->size(), __str._M_data(), __size);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    append(const basic_string& __str, size_type __pos, size_type __n)
    {
      __str._M_check(__pos, "basic_string::append");
      __n = __str._M_limit(__pos, __n);
      if (__n)
 {
   const size_type __len = __n + this->size();
   if (__len > this->capacity() || _M_rep()->_M_is_shared())
     this->reserve(__len);
   _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
   _M_rep()->_M_set_length_and_sharable(__len);
 }
      return *this;
    }

   template<typename _CharT, typename _Traits, typename _Alloc>
     basic_string<_CharT, _Traits, _Alloc>&
     basic_string<_CharT, _Traits, _Alloc>::
     insert(size_type __pos, const _CharT* __s, size_type __n)
     {
       ;
       _M_check(__pos, "basic_string::insert");
       _M_check_length(size_type(0), __n, "basic_string::insert");
       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
         return _M_replace_safe(__pos, size_type(0), __s, __n);
       else
         {

           const size_type __off = __s - _M_data();
           _M_mutate(__pos, 0, __n);
           __s = _M_data() + __off;
           _CharT* __p = _M_data() + __pos;
           if (__s + __n <= __p)
             _M_copy(__p, __s, __n);
           else if (__s >= __p)
             _M_copy(__p, __s + __n, __n);
           else
             {
        const size_type __nleft = __p - __s;
               _M_copy(__p, __s, __nleft);
               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
             }
           return *this;
         }
     }

   template<typename _CharT, typename _Traits, typename _Alloc>
     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"));
# 558 "/usr/include/c++/4.1.3/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
    {
      ;
      size_type __ret = npos;
      const size_type __size = this->size();
      if (__pos + __n <= __size)
 {
   const _CharT* __data = _M_data();
   const _CharT* __p = std::search(__data + __pos, __data + __size,
       __s, __s + __n, traits_type::eq);
   if (__p != __data + __size || __n == 0)
     __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>::
    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 = __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 = __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 = __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 = __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 = __n1 - __n2;
      return __r;
    }





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


}
# 57 "/usr/include/c++/4.1.3/string" 2 3
# 48 "/usr/include/c++/4.1.3/bits/locale_classes.h" 2 3



namespace std
{
# 67 "/usr/include/c++/4.1.3/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;
# 105 "/usr/include/c++/4.1.3/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);
# 124 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    locale() throw();
# 133 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 143 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 158 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 171 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 183 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


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






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







    inline bool
    operator!=(const locale& __other) const throw ()
    { return !(this->operator==(__other)); }
# 259 "/usr/include/c++/4.1.3/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;
# 275 "/usr/include/c++/4.1.3/bits/locale_classes.h" 3
    static locale
    global(const locale&);




    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 310 "/usr/include/c++/4.1.3/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();

    static category
    _S_normalize_category(category);

    void
    _M_coalesce(const locale& __base, const locale& __add, category __cat);
  };
# 343 "/usr/include/c++/4.1.3/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:
# 374 "/usr/include/c++/4.1.3/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);

    static void
    _S_destroy_c_locale(__c_locale& __cloc);



    static __c_locale
    _S_get_c_locale();

    static const char*
    _S_get_c_name();

  private:
    inline void
    _M_add_reference() const throw()
    { __gnu_cxx::__atomic_add(&_M_refcount, 1); }

    inline void
    _M_remove_reference() const throw()
    {
      if (__gnu_cxx::__exchange_and_add(&_M_refcount, -1) == 1)
 {
   try
     { delete this; }
   catch (...)
     { }
 }
    }

    facet(const facet&);

    facet&
    operator=(const facet&);
  };
# 434 "/usr/include/c++/4.1.3/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;
  };



  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[];

    inline void
    _M_add_reference() throw()
    { __gnu_cxx::__atomic_add(&_M_refcount, 1); }

    inline void
    _M_remove_reference() throw()
    {
      if (__gnu_cxx::__exchange_and_add(&_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&);

    inline 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 = std::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>
      inline void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    void
    _M_install_cache(const facet*, size_t);
  };

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

namespace std
{




  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, _Ios_Fmtflags __b)
  { return __a = __a | __b; }

  inline _Ios_Fmtflags&
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a & __b; }

  inline _Ios_Fmtflags&
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
  { return __a = __a ^ __b; }

  inline _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a)
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }


  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, _Ios_Openmode __b)
  { return __a = __a | __b; }

  inline _Ios_Openmode&
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a & __b; }

  inline _Ios_Openmode&
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
  { return __a = __a ^ __b; }

  inline _Ios_Openmode
  operator~(_Ios_Openmode __a)
  { return _Ios_Openmode(~static_cast<int>(__a)); }


  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, _Ios_Iostate __b)
  { return __a = __a | __b; }

  inline _Ios_Iostate&
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a & __b; }

  inline _Ios_Iostate&
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
  { return __a = __a ^ __b; }

  inline _Ios_Iostate
  operator~(_Ios_Iostate __a)
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  enum _Ios_Seekdir
    {
      _S_beg = 0,
      _S_cur = 1,
      _S_end = 2,
      _S_ios_seekdir_end = 1L << 16
    };
# 201 "/usr/include/c++/4.1.3/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;
    };
# 253 "/usr/include/c++/4.1.3/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;
# 328 "/usr/include/c++/4.1.3/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;
# 359 "/usr/include/c++/4.1.3/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;
# 392 "/usr/include/c++/4.1.3/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;
# 418 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 435 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    typedef void (*event_callback) (event, ios_base&, int);
# 447 "/usr/include/c++/4.1.3/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(&_M_refcount, 1); }


      int
      _M_remove_reference()
      { return __gnu_cxx::__exchange_and_add(&_M_refcount, -1); }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void);


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

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();

    private:
      static _Atomic_word _S_refcount;
      static bool _S_synced_with_stdio;
    };






    inline fmtflags
    flags() const { return _M_flags; }
# 557 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 573 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 590 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }







    inline void
    unsetf(fmtflags __mask) { _M_flags &= ~__mask; }
# 617 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline streamsize
    precision() const { return _M_precision; }






    inline streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }







    inline streamsize
    width() const { return _M_width; }






    inline streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 666 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 678 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc);
# 689 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline locale
    getloc() const { return _M_ios_locale; }
# 699 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline const locale&
    _M_getloc() const { return _M_ios_locale; }
# 717 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 733 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline long&
    iword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 754 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    inline void*&
    pword(int __ix)
    {
      _Words& __word = (__ix < _M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 771 "/usr/include/c++/4.1.3/bits/ios_base.h" 3
    virtual ~ios_base();

  protected:
    ios_base();



  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;
  }
}
# 49 "/usr/include/c++/4.1.3/ios" 2 3
# 1 "/usr/include/c++/4.1.3/streambuf" 1 3
# 42 "/usr/include/c++/4.1.3/streambuf" 3
       
# 43 "/usr/include/c++/4.1.3/streambuf" 3






namespace std
{





  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout);
# 121 "/usr/include/c++/4.1.3/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;
# 144 "/usr/include/c++/4.1.3/streambuf" 3
      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<>(__streambuf_type* __sbin,
     __streambuf_type* __sbout);

      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:
# 182 "/usr/include/c++/4.1.3/streambuf" 3
      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()
      { }
# 210 "/usr/include/c++/4.1.3/streambuf" 3
      locale
      pubimbue(const locale &__loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 227 "/usr/include/c++/4.1.3/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 240 "/usr/include/c++/4.1.3/streambuf" 3
      __streambuf_type*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }

      pos_type
      pubseekoff(off_type __off, ios_base::seekdir __way,
   ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekoff(__off, __way, __mode); }

      pos_type
      pubseekpos(pos_type __sp,
   ios_base::openmode __mode = ios_base::in | ios_base::out)
      { return this->seekpos(__sp, __mode); }

      int
      pubsync() { return this->sync(); }
# 267 "/usr/include/c++/4.1.3/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 281 "/usr/include/c++/4.1.3/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;
      }
# 299 "/usr/include/c++/4.1.3/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;
      }
# 321 "/usr/include/c++/4.1.3/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;
      }
# 340 "/usr/include/c++/4.1.3/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 354 "/usr/include/c++/4.1.3/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;
      }
# 379 "/usr/include/c++/4.1.3/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;
      }
# 406 "/usr/include/c++/4.1.3/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;
      }
# 432 "/usr/include/c++/4.1.3/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 446 "/usr/include/c++/4.1.3/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())
      { }
# 464 "/usr/include/c++/4.1.3/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; }
# 480 "/usr/include/c++/4.1.3/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 491 "/usr/include/c++/4.1.3/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;
      }
# 511 "/usr/include/c++/4.1.3/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; }
# 527 "/usr/include/c++/4.1.3/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 537 "/usr/include/c++/4.1.3/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 558 "/usr/include/c++/4.1.3/streambuf" 3
      virtual void
      imbue(const locale&)
      { }
# 573 "/usr/include/c++/4.1.3/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 584 "/usr/include/c++/4.1.3/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)); }
# 596 "/usr/include/c++/4.1.3/streambuf" 3
      virtual pos_type
      seekpos(pos_type,
       ios_base::openmode = ios_base::in | ios_base::out)
      { return pos_type(off_type(-1)); }
# 609 "/usr/include/c++/4.1.3/streambuf" 3
      virtual int
      sync() { return 0; }
# 631 "/usr/include/c++/4.1.3/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 647 "/usr/include/c++/4.1.3/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 669 "/usr/include/c++/4.1.3/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 682 "/usr/include/c++/4.1.3/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;
      }
# 706 "/usr/include/c++/4.1.3/streambuf" 3
      virtual int_type
      pbackfail(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 724 "/usr/include/c++/4.1.3/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 749 "/usr/include/c++/4.1.3/streambuf" 3
      virtual int_type
      overflow(int_type = traits_type::eof())
      { return traits_type::eof(); }
# 778 "/usr/include/c++/4.1.3/streambuf" 3
    private:


      basic_streambuf(const __streambuf_type& __sb)
      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
      _M_buf_locale(__sb._M_buf_locale)
      { }

      __streambuf_type&
      operator=(const __streambuf_type&) { return *this; };
    };


  template<>
    streamsize
    __copy_streambufs(basic_streambuf<char>* __sbin,
        basic_streambuf<char>* __sbout);

  template<>
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>* __sbin,
        basic_streambuf<wchar_t>* __sbout);

}


# 1 "/usr/include/c++/4.1.3/bits/streambuf.tcc" 1 3
# 43 "/usr/include/c++/4.1.3/bits/streambuf.tcc" 3
       
# 44 "/usr/include/c++/4.1.3/bits/streambuf.tcc" 3

namespace std
{
  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->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->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(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      streamsize __ret = 0;
      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()))
     break;
   ++__ret;
   __c = __sbin->snextc();
 }
      return __ret;
    }





  extern template class basic_streambuf<char>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<char>*, basic_streambuf<char>*);


  extern template class basic_streambuf<wchar_t>;
  extern template
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>*, basic_streambuf<wchar_t>*);


}
# 807 "/usr/include/c++/4.1.3/streambuf" 2 3
# 50 "/usr/include/c++/4.1.3/ios" 2 3
# 1 "/usr/include/c++/4.1.3/bits/basic_ios.h" 1 3
# 39 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
       
# 40 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3

# 1 "/usr/include/c++/4.1.3/bits/streambuf_iterator.h" 1 3
# 39 "/usr/include/c++/4.1.3/bits/streambuf_iterator.h" 3
       
# 40 "/usr/include/c++/4.1.3/bits/streambuf_iterator.h" 3






namespace std
{


  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;


    private:







      mutable streambuf_type* _M_sbuf;
      mutable int_type _M_c;

    public:

      istreambuf_iterator() throw()
      : _M_sbuf(0), _M_c(traits_type::eof()) { }


      istreambuf_iterator(istream_type& __s) throw()
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


      istreambuf_iterator(streambuf_type* __s) throw()
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }




      char_type
      operator*() const
      {







 return traits_type::to_char_type(_M_get());
      }


      istreambuf_iterator&
      operator++()
      {
 ;


 if (_M_sbuf)
   {
     _M_sbuf->sbumpc();
     _M_c = traits_type::eof();
   }
 return *this;
      }


      istreambuf_iterator
      operator++(int)
      {
 ;



 istreambuf_iterator __old = *this;
 if (_M_sbuf)
   {
     __old._M_c = _M_sbuf->sbumpc();
     _M_c = traits_type::eof();
   }
 return __old;
      }





      bool
      equal(const istreambuf_iterator& __b) const
      {
 const bool __thiseof = _M_at_eof();
 const bool __beof = __b._M_at_eof();
 return (__thiseof && __beof || (!__thiseof && !__beof));
      }

    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;


    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;
      }
    };
}
# 42 "/usr/include/c++/4.1.3/bits/basic_ios.h" 2 3


# 1 "/usr/include/c++/4.1.3/bits/locale_facets.h" 1 3
# 43 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
       
# 44 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3


# 1 "/usr/include/c++/4.1.3/cwctype" 1 3
# 48 "/usr/include/c++/4.1.3/cwctype" 3
       
# 49 "/usr/include/c++/4.1.3/cwctype" 3




# 1 "/usr/include/wctype.h" 1 3 4
# 34 "/usr/include/wctype.h" 3 4
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stddef.h" 1 3 4
# 35 "/usr/include/wctype.h" 2 3 4
# 50 "/usr/include/wctype.h" 3 4



typedef unsigned long int wctype_t;

# 72 "/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 ();
# 172 "/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 ();


}
# 214 "/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 ();



}
# 54 "/usr/include/c++/4.1.3/cwctype" 2 3
# 79 "/usr/include/c++/4.1.3/cwctype" 3
namespace std
{
  using ::wint_t;

  using ::wctype_t;
  using ::wctrans_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;
}
# 47 "/usr/include/c++/4.1.3/bits/locale_facets.h" 2 3




namespace std
{
# 63 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  template<typename _Tv>
    void
    __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err,
     const __c_locale& __cloc);


  template<>
    void
    __convert_to_v(const char*, float&, ios_base::iostate&,
     const __c_locale&);

  template<>
    void
    __convert_to_v(const char*, double&, ios_base::iostate&,
     const __c_locale&);

  template<>
    void
    __convert_to_v(const char*, long double&, ios_base::iostate&,
     const __c_locale&);



  template<typename _CharT, typename _Traits>
    struct __pad
    {
      static void
      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
      const _CharT* __olds, const streamsize __newlen,
      const streamsize __oldlen, const bool __num);
    };






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




# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/ctype_base.h" 1 3
# 43 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/ctype_base.h" 3
  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;
  };
# 133 "/usr/include/c++/4.1.3/bits/locale_facets.h" 2 3
# 144 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 162 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 179 "/usr/include/c++/4.1.3/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); }
# 195 "/usr/include/c++/4.1.3/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); }
# 211 "/usr/include/c++/4.1.3/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); }
# 225 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 240 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 254 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 269 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 286 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 305 "/usr/include/c++/4.1.3/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); }
# 324 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 346 "/usr/include/c++/4.1.3/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() { }
# 371 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 390 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 409 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 428 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 446 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const = 0;
# 463 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 479 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const = 0;
# 496 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 515 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const = 0;
# 536 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi,
        char_type* __dest) const = 0;
# 558 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const = 0;
# 582 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const = 0;
    };
# 605 "/usr/include/c++/4.1.3/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* __dest) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;
# 674 "/usr/include/c++/4.1.3/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);
# 711 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 724 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 737 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 752 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 766 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 780 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 795 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 812 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 828 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 845 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 865 "/usr/include/c++/4.1.3/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);
      }
# 892 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (_M_widen_ok == 1)
   {
     memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_widen_ok)
   _M_widen_init();
 return this->do_widen(__lo, __hi, __to);
      }
# 923 "/usr/include/c++/4.1.3/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;
      }
# 956 "/usr/include/c++/4.1.3/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))
   {
     memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_narrow_ok)
   _M_narrow_init();
 return this->do_narrow(__lo, __hi, __dfault, __to);
      }

    protected:


      const mask*
      table() const throw()
      { return _M_table; }


      static const mask*
      classic_table() throw();







      virtual
      ~ctype();
# 1003 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1020 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1036 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1053 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1073 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1096 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
      {
 memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }
# 1122 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char) const
      { return __c; }
# 1148 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char, char* __dest) const
      {
 memcpy(__dest, __lo, __hi - __lo);
 return __hi;
      }

    private:

      void _M_widen_init() const
      {
 char __tmp[sizeof(_M_widen)];
 for (size_t __i = 0; __i < sizeof(_M_widen); ++__i)
   __tmp[__i] = __i;
 do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen);

 _M_widen_ok = 1;

 if (memcmp(__tmp, _M_widen, sizeof(_M_widen)))
   _M_widen_ok = 2;
      }




      void _M_narrow_init() const
      {
 char __tmp[sizeof(_M_narrow)];
 for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i)
   __tmp[__i] = __i;
 do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow);

 _M_narrow_ok = 1;
 if (memcmp(__tmp, _M_narrow, sizeof(_M_narrow)))
   _M_narrow_ok = 2;
 else
   {


     char __c;
     do_narrow(__tmp, __tmp + 1, 1, &__c);
     if (__c == 1)
       _M_narrow_ok = 2;
   }
      }
    };

  template<>
    const ctype<char>&
    use_facet<ctype<char> >(const locale& __loc);
# 1212 "/usr/include/c++/4.1.3/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;
# 1245 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1256 "/usr/include/c++/4.1.3/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;


      virtual
      ~ctype();
# 1280 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1299 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1317 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1335 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1352 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type) const;
# 1369 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1385 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type) const;
# 1402 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1422 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char) const;
# 1444 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
# 1467 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type, char __dfault) const;
# 1493 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __dest) const;


      void
      _M_initialize_ctype();
    };

  template<>
    const ctype<wchar_t>&
    use_facet<ctype<wchar_t> >(const locale& __loc);



# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/ctype_inline.h" 1 3
# 37 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/ctype_inline.h" 3
  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;
  }
# 1509 "/usr/include/c++/4.1.3/bits/locale_facets.h" 2 3


  template<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef _CharT char_type;

      explicit
      ctype_byname(const char* __s, size_t __refs = 0);

    protected:
      virtual
      ~ctype_byname() { };
    };


  template<>
    ctype_byname<char>::ctype_byname(const char*, size_t refs);

  template<>
    ctype_byname<wchar_t>::ctype_byname(const char*, size_t refs);


# 1 "/usr/include/c++/4.1.3/bits/codecvt.h" 1 3
# 45 "/usr/include/c++/4.1.3/bits/codecvt.h" 3
       
# 46 "/usr/include/c++/4.1.3/bits/codecvt.h" 3


  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 69 "/usr/include/c++/4.1.3/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;
# 117 "/usr/include/c++/4.1.3/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);
      }
# 156 "/usr/include/c++/4.1.3/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); }
# 197 "/usr/include/c++/4.1.3/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() { }
# 238 "/usr/include/c++/4.1.3/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;
    };



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;


  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };



  template<>
    class codecvt<wchar_t, char, mbstate_t>
    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
    {
    public:

      typedef wchar_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };



  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char* __s, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs)
      {
 if (std::strcmp(__s, "C") != 0 && std::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() { }
    };
# 1534 "/usr/include/c++/4.1.3/bits/locale_facets.h" 2 3


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

  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(__null), _M_grouping_size(0), _M_use_grouping(false),
      _M_truename(__null), _M_truename_size(0), _M_falsename(__null),
      _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;
 }
    }
# 1656 "/usr/include/c++/4.1.3/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(__null)
      { _M_initialize_numpunct(); }
# 1693 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1707 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_numpunct(__cloc); }
# 1721 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1734 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1765 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1778 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1791 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1808 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1820 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1833 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1846 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1859 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_falsename() const
      { return _M_data->_M_falsename; }


      void
      _M_initialize_numpunct(__c_locale __cloc = __null);
    };

  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 (std::strcmp(__s, "C") != 0 && std::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() { }
    };


# 1926 "/usr/include/c++/4.1.3/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;
# 1947 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 1973 "/usr/include/c++/4.1.3/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); }
# 2009 "/usr/include/c++/4.1.3/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); }
# 2068 "/usr/include/c++/4.1.3/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); }
# 2110 "/usr/include/c++/4.1.3/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& __xtrc) const;

      template<typename _ValueT>
        iter_type
        _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
         _ValueT& __v) const;
# 2143 "/usr/include/c++/4.1.3/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, iter_type, ios_base&, ios_base::iostate&, long&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
       unsigned short&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
      unsigned int&) const;

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


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

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


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

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







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


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

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2219 "/usr/include/c++/4.1.3/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;
# 2240 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2258 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2300 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
      { return this->do_put(__s, __f, __fill, __v); }

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


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

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

      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   long double __v) const
      { return this->do_put(__s, __f, __fill, __v); }
# 2388 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __f, char_type __fill,
   const void* __v) const
      { return this->do_put(__s, __f, __fill, __v); }

    protected:
      template<typename _ValueT>
        iter_type
        _M_insert_float(iter_type, ios_base& __io, char_type __fill,
   char __mod, _ValueT __v) const;

      void
      _M_group_float(const char* __grouping, size_t __grouping_size,
       char_type __sep, const char_type* __p, char_type* __new,
       char_type* __cs, int& __len) const;

      template<typename _ValueT>
        iter_type
        _M_insert_int(iter_type, ios_base& __io, char_type __fill,
        _ValueT __v) const;

      void
      _M_group_int(const char* __grouping, size_t __grouping_size,
     char_type __sep, ios_base& __io, char_type* __new,
     char_type* __cs, int& __len) const;

      void
      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
      char_type* __new, const char_type* __cs, int& __len) const;


      virtual
      ~num_put() { };
# 2436 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;

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

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


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

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


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






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


      virtual iter_type
      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;







    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;


# 2493 "/usr/include/c++/4.1.3/bits/locale_facets.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;
# 2520 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 2534 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 2551 "/usr/include/c++/4.1.3/bits/locale_facets.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); }
# 2570 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 2584 "/usr/include/c++/4.1.3/bits/locale_facets.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;

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const;

  protected:

      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }
# 2613 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 2629 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 2642 "/usr/include/c++/4.1.3/bits/locale_facets.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;

  template<>
    size_t
    collate<char>::_M_transform(char*, const char*, size_t) const;


  template<>
    int
    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const;

  template<>
    size_t
    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const;



  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 (std::strcmp(__s, "C") != 0 && std::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() { }
    };
# 2702 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    struct __timepunct_cache : public locale::facet
    {

      static const _CharT* _S_timezones[14];

      const _CharT* _M_date_format;
      const _CharT* _M_date_era_format;
      const _CharT* _M_time_format;
      const _CharT* _M_time_era_format;
      const _CharT* _M_date_time_format;
      const _CharT* _M_date_time_era_format;
      const _CharT* _M_am;
      const _CharT* _M_pm;
      const _CharT* _M_am_pm_format;


      const _CharT* _M_day1;
      const _CharT* _M_day2;
      const _CharT* _M_day3;
      const _CharT* _M_day4;
      const _CharT* _M_day5;
      const _CharT* _M_day6;
      const _CharT* _M_day7;


      const _CharT* _M_aday1;
      const _CharT* _M_aday2;
      const _CharT* _M_aday3;
      const _CharT* _M_aday4;
      const _CharT* _M_aday5;
      const _CharT* _M_aday6;
      const _CharT* _M_aday7;


      const _CharT* _M_month01;
      const _CharT* _M_month02;
      const _CharT* _M_month03;
      const _CharT* _M_month04;
      const _CharT* _M_month05;
      const _CharT* _M_month06;
      const _CharT* _M_month07;
      const _CharT* _M_month08;
      const _CharT* _M_month09;
      const _CharT* _M_month10;
      const _CharT* _M_month11;
      const _CharT* _M_month12;


      const _CharT* _M_amonth01;
      const _CharT* _M_amonth02;
      const _CharT* _M_amonth03;
      const _CharT* _M_amonth04;
      const _CharT* _M_amonth05;
      const _CharT* _M_amonth06;
      const _CharT* _M_amonth07;
      const _CharT* _M_amonth08;
      const _CharT* _M_amonth09;
      const _CharT* _M_amonth10;
      const _CharT* _M_amonth11;
      const _CharT* _M_amonth12;

      bool _M_allocated;

      __timepunct_cache(size_t __refs = 0) : facet(__refs),
      _M_date_format(__null), _M_date_era_format(__null), _M_time_format(__null),
      _M_time_era_format(__null), _M_date_time_format(__null),
      _M_date_time_era_format(__null), _M_am(__null), _M_pm(__null),
      _M_am_pm_format(__null), _M_day1(__null), _M_day2(__null), _M_day3(__null),
      _M_day4(__null), _M_day5(__null), _M_day6(__null), _M_day7(__null),
      _M_aday1(__null), _M_aday2(__null), _M_aday3(__null), _M_aday4(__null),
      _M_aday5(__null), _M_aday6(__null), _M_aday7(__null), _M_month01(__null),
      _M_month02(__null), _M_month03(__null), _M_month04(__null), _M_month05(__null),
      _M_month06(__null), _M_month07(__null), _M_month08(__null), _M_month09(__null),
      _M_month10(__null), _M_month11(__null), _M_month12(__null), _M_amonth01(__null),
      _M_amonth02(__null), _M_amonth03(__null), _M_amonth04(__null),
      _M_amonth05(__null), _M_amonth06(__null), _M_amonth07(__null),
      _M_amonth08(__null), _M_amonth09(__null), _M_amonth10(__null),
      _M_amonth11(__null), _M_amonth12(__null), _M_allocated(false)
      { }

      ~__timepunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __timepunct_cache&
      operator=(const __timepunct_cache&);

      explicit
      __timepunct_cache(const __timepunct_cache&);
    };

  template<typename _CharT>
    __timepunct_cache<_CharT>::~__timepunct_cache()
    {
      if (_M_allocated)
 {

 }
    }


  template<>
    const char*
    __timepunct_cache<char>::_S_timezones[14];


  template<>
    const wchar_t*
    __timepunct_cache<wchar_t>::_S_timezones[14];



  template<typename _CharT>
    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];

  template<typename _CharT>
    class __timepunct : public locale::facet
    {
    public:

      typedef _CharT __char_type;
      typedef basic_string<_CharT> __string_type;
      typedef __timepunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;
      __c_locale _M_c_locale_timepunct;
      const char* _M_name_timepunct;

    public:

      static locale::id id;

      explicit
      __timepunct(size_t __refs = 0);

      explicit
      __timepunct(__cache_type* __cache, size_t __refs = 0);
# 2860 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);



      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const;

      void
      _M_date_formats(const _CharT** __date) const
      {

 __date[0] = _M_data->_M_date_format;
 __date[1] = _M_data->_M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

 __time[0] = _M_data->_M_time_format;
 __time[1] = _M_data->_M_time_era_format;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

 __dt[0] = _M_data->_M_date_time_format;
 __dt[1] = _M_data->_M_date_time_era_format;
      }

      void
      _M_am_pm_format(const _CharT* __ampm) const
      { __ampm = _M_data->_M_am_pm_format; }

      void
      _M_am_pm(const _CharT** __ampm) const
      {
 __ampm[0] = _M_data->_M_am;
 __ampm[1] = _M_data->_M_pm;
      }

      void
      _M_days(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_day1;
 __days[1] = _M_data->_M_day2;
 __days[2] = _M_data->_M_day3;
 __days[3] = _M_data->_M_day4;
 __days[4] = _M_data->_M_day5;
 __days[5] = _M_data->_M_day6;
 __days[6] = _M_data->_M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_aday1;
 __days[1] = _M_data->_M_aday2;
 __days[2] = _M_data->_M_aday3;
 __days[3] = _M_data->_M_aday4;
 __days[4] = _M_data->_M_aday5;
 __days[5] = _M_data->_M_aday6;
 __days[6] = _M_data->_M_aday7;
      }

      void
      _M_months(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_month01;
 __months[1] = _M_data->_M_month02;
 __months[2] = _M_data->_M_month03;
 __months[3] = _M_data->_M_month04;
 __months[4] = _M_data->_M_month05;
 __months[5] = _M_data->_M_month06;
 __months[6] = _M_data->_M_month07;
 __months[7] = _M_data->_M_month08;
 __months[8] = _M_data->_M_month09;
 __months[9] = _M_data->_M_month10;
 __months[10] = _M_data->_M_month11;
 __months[11] = _M_data->_M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_amonth01;
 __months[1] = _M_data->_M_amonth02;
 __months[2] = _M_data->_M_amonth03;
 __months[3] = _M_data->_M_amonth04;
 __months[4] = _M_data->_M_amonth05;
 __months[5] = _M_data->_M_amonth06;
 __months[6] = _M_data->_M_amonth07;
 __months[7] = _M_data->_M_amonth08;
 __months[8] = _M_data->_M_amonth09;
 __months[9] = _M_data->_M_amonth10;
 __months[10] = _M_data->_M_amonth11;
 __months[11] = _M_data->_M_amonth12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = __null);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    void
    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const;


  template<>
    void
    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
     const tm*) const;



# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/time_members.h" 1 3
# 37 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/time_members.h" 3
  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(size_t __refs)
    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
      _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(__null),
      _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
         size_t __refs)
    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
      _M_name_timepunct(__null)
    {
      const size_t __len = std::strlen(__s) + 1;
      char* __tmp = new char[__len];
      std::memcpy(__tmp, __s, __len);
      _M_name_timepunct = __tmp;

      try
 { _M_initialize_timepunct(__cloc); }
      catch(...)
 {
   delete [] _M_name_timepunct;
   throw;
 }
    }

  template<typename _CharT>
    __timepunct<_CharT>::~__timepunct()
    {
      if (_M_name_timepunct != _S_get_c_name())
 delete [] _M_name_timepunct;
      delete _M_data;
      _S_destroy_c_locale(_M_c_locale_timepunct);
    }
# 2996 "/usr/include/c++/4.1.3/bits/locale_facets.h" 2 3
# 3009 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;

      typedef basic_string<_CharT> __string_type;


      static locale::id id;
# 3031 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 3048 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 3072 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 3097 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 3125 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 3154 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 3180 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }

    protected:

      virtual
      ~time_get() { }
# 3200 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual dateorder
      do_date_order() const;
# 3218 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 3237 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 3256 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 3275 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 3294 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;


      iter_type
      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
       int __min, int __max, size_t __len,
       ios_base& __io, ios_base::iostate& __err) const;



      iter_type
      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const;


      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;


  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }

    protected:
      virtual
      ~time_get_byname() { }
    };
# 3350 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 3371 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 3390 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
   const _CharT* __beg, const _CharT* __end) const;
# 3410 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const tm* __tm, char __format, char __mod = 0) const
      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }

    protected:

      virtual
      ~time_put()
      { }
# 3437 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
      char __format, char __mod) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;


  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter>(__refs)
      { };

    protected:
      virtual
      ~time_put_byname() { }
    };
# 3475 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;

    enum
    {
      _S_minus,
      _S_zero,
      _S_end = 11
    };



    static const char* _S_atoms;



    static pattern
    _S_construct_pattern(char __precedes, char __space, char __posn);
  };

  template<typename _CharT, bool _Intl>
    struct __moneypunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;
      const _CharT* _M_curr_symbol;
      size_t _M_curr_symbol_size;
      const _CharT* _M_positive_sign;
      size_t _M_positive_sign_size;
      const _CharT* _M_negative_sign;
      size_t _M_negative_sign_size;
      int _M_frac_digits;
      money_base::pattern _M_pos_format;
      money_base::pattern _M_neg_format;




      _CharT _M_atoms[money_base::_S_end];

      bool _M_allocated;

      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
      _M_curr_symbol(__null), _M_curr_symbol_size(0),
      _M_positive_sign(__null), _M_positive_sign_size(0),
      _M_negative_sign(__null), _M_negative_sign_size(0),
      _M_frac_digits(0),
      _M_pos_format(money_base::pattern()),
      _M_neg_format(money_base::pattern()), _M_allocated(false)
      { }

      ~__moneypunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __moneypunct_cache&
      operator=(const __moneypunct_cache&);

      explicit
      __moneypunct_cache(const __moneypunct_cache&);
    };

  template<typename _CharT, bool _Intl>
    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_curr_symbol;
   delete [] _M_positive_sign;
   delete [] _M_negative_sign;
 }
    }







  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

    private:
      __cache_type* _M_data;

    public:


      static const bool intl = _Intl;

      static locale::id id;
# 3596 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(); }
# 3608 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 3623 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(__null)
      { _M_initialize_moneypunct(__cloc, __s); }
# 3637 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 3650 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 3679 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 3692 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 3709 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 3726 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 3742 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 3777 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 3799 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 3811 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 3824 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 3837 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 3850 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 3863 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 3877 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 3891 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 3905 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual pattern
      do_neg_format() const
      { return _M_data->_M_neg_format; }


       void
       _M_initialize_moneypunct(__c_locale __cloc = __null,
    const char* __name = __null);
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<>
    moneypunct<char, true>::~moneypunct();

  template<>
    moneypunct<char, false>::~moneypunct();

  template<>
    void
    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);

  template<>
    void
    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);


  template<>
    moneypunct<wchar_t, true>::~moneypunct();

  template<>
    moneypunct<wchar_t, false>::~moneypunct();

  template<>
    void
    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
       const char*);

  template<>
    void
    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
        const char*);



  template<typename _CharT, bool _Intl>
    class moneypunct_byname : public moneypunct<_CharT, _Intl>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;

      explicit
      moneypunct_byname(const char* __s, size_t __refs = 0)
      : moneypunct<_CharT, _Intl>(__refs)
      {
 if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_moneypunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }

    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;


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



      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 4019 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 4049 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 4079 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:

      virtual
      ~money_get() { }
# 4102 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 4114 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;
# 4125 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      template<bool _Intl>
        iter_type
        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, string& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;
# 4146 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:


      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 4167 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 4187 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, long double __units) const
      { return this->do_put(__s, __intl, __io, __fill, __units); }
# 4209 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:

      virtual
      ~money_put() { }
# 4243 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 4266 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;
# 4277 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      template<bool _Intl>
        iter_type
        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
    const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;






  struct messages_base
  {
    typedef int catalog;
  };
# 4316 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_messages;
      const char* _M_name_messages;

    public:

      static locale::id id;
# 4344 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      messages(size_t __refs = 0);
# 4358 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 4371 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 4389 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 4407 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 4418 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 4438 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 4457 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;






      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char*) const
      {
# 4514 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
 return string_type();
      }
     };

  template<typename _CharT>
    locale::id messages<_CharT>::id;


  template<>
    string
    messages<char>::do_get(catalog, int, int, const string&) const;


  template<>
    wstring
    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;



   template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      messages_byname(const char* __s, size_t __refs = 0);

    protected:
      virtual
      ~messages_byname()
      { }
    };


# 1 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/messages_members.h" 1 3
# 37 "/usr/include/c++/4.1.3/x86_64-linux-gnu/bits/messages_members.h" 3
  template<typename _CharT>
     messages<_CharT>::messages(size_t __refs)
     : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
       _M_name_messages(_S_get_c_name())
     { }

  template<typename _CharT>
     messages<_CharT>::messages(__c_locale __cloc, const char* __s,
    size_t __refs)
     : facet(__refs), _M_c_locale_messages(__null), _M_name_messages(__null)
     {
       const size_t __len = std::strlen(__s) + 1;
       char* __tmp = new char[__len];
       std::memcpy(__tmp, __s, __len);
       _M_name_messages = __tmp;


       _M_c_locale_messages = _S_clone_c_locale(__cloc);
     }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
      const char* __dir) const
    {
      bindtextdomain(__s.c_str(), __dir);
      return this->do_open(__s, __loc);
    }


  template<typename _CharT>
    messages<_CharT>::~messages()
    {
      if (_M_name_messages != _S_get_c_name())
 delete [] _M_name_messages;
      _S_destroy_c_locale(_M_c_locale_messages);
    }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::do_open(const basic_string<char>& __s,
         const locale&) const
    {


      textdomain(__s.c_str());
      return 0;
    }

  template<typename _CharT>
    void
    messages<_CharT>::do_close(catalog) const
    { }


   template<typename _CharT>
     messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
     : messages<_CharT>(__refs)
     {
       if (this->_M_name_messages != locale::facet::_S_get_c_name())
  delete [] this->_M_name_messages;
       char* __tmp = new char[std::strlen(__s) + 1];
       std::strcpy(__tmp, __s);
       this->_M_name_messages = __tmp;

       if (std::strcmp(__s, "C") != 0 && std::strcmp(__s, "POSIX") != 0)
  {
    this->_S_destroy_c_locale(this->_M_c_locale_messages);
    this->_S_create_c_locale(this->_M_c_locale_messages, __s);
  }
     }
# 4551 "/usr/include/c++/4.1.3/bits/locale_facets.h" 2 3
# 4559 "/usr/include/c++/4.1.3/bits/locale_facets.h" 3
  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); }
}
# 45 "/usr/include/c++/4.1.3/bits/basic_ios.h" 2 3

namespace std
{







  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;
# 78 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      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(); }
# 122 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 133 "/usr/include/c++/4.1.3/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; }
# 186 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 207 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 242 "/usr/include/c++/4.1.3/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() { }
# 280 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 292 "/usr/include/c++/4.1.3/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; }
# 332 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 346 "/usr/include/c++/4.1.3/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;
      }
# 375 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 395 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 415 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const;
# 433 "/usr/include/c++/4.1.3/bits/basic_ios.h" 3
      char_type
      widen(char __c) const;

    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.1.3/bits/basic_ios.tcc" 1 3
# 38 "/usr/include/c++/4.1.3/bits/basic_ios.tcc" 3
       
# 39 "/usr/include/c++/4.1.3/bits/basic_ios.tcc" 3

namespace std
{
  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>
    char
    basic_ios<_CharT, _Traits>::narrow(char_type __c, char __dfault) const
    { return __check_facet(_M_ctype).narrow(__c, __dfault); }

  template<typename _CharT, typename _Traits>
    _CharT
    basic_ios<_CharT, _Traits>::widen(char __c) const
    { return __check_facet(_M_ctype).widen(__c); }


  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);
# 159 "/usr/include/c++/4.1.3/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>;


}
# 465 "/usr/include/c++/4.1.3/bits/basic_ios.h" 2 3
# 51 "/usr/include/c++/4.1.3/ios" 2 3
# 45 "/usr/include/c++/4.1.3/ostream" 2 3

namespace std
{
# 56 "/usr/include/c++/4.1.3/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;

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, _CharT2);

      template<typename _Traits2>
        friend basic_ostream<char, _Traits2>&
        operator<<(basic_ostream<char, _Traits2>&, char);

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, const _CharT2*);

      template<typename _Traits2>
        friend basic_ostream<char, _Traits2>&
        operator<<(basic_ostream<char, _Traits2>&, const char*);

      template<typename _CharT2, typename _Traits2>
        friend basic_ostream<_CharT2, _Traits2>&
        operator<<(basic_ostream<_CharT2, _Traits2>&, const char*);
# 103 "/usr/include/c++/4.1.3/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 129 "/usr/include/c++/4.1.3/ostream" 3
      inline __ostream_type&
      operator<<(__ostream_type& (*__pf)(__ostream_type&));

      inline __ostream_type&
      operator<<(__ios_type& (*__pf)(__ios_type&));

      inline __ostream_type&
      operator<<(ios_base& (*__pf) (ios_base&));
# 166 "/usr/include/c++/4.1.3/ostream" 3
      __ostream_type&
      operator<<(long __n);

      __ostream_type&
      operator<<(unsigned long __n);

      __ostream_type&
      operator<<(bool __n);

      __ostream_type&
      operator<<(short __n);

      __ostream_type&
      operator<<(unsigned short __n);

      __ostream_type&
      operator<<(int __n);

      __ostream_type&
      operator<<(unsigned int __n);


      __ostream_type&
      operator<<(long long __n);

      __ostream_type&
      operator<<(unsigned long long __n);


      __ostream_type&
      operator<<(double __f);

      __ostream_type&
      operator<<(float __f);

      __ostream_type&
      operator<<(long double __f);

      __ostream_type&
      operator<<(const void* __p);
# 228 "/usr/include/c++/4.1.3/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 261 "/usr/include/c++/4.1.3/ostream" 3
      __ostream_type&
      put(char_type __c);


      void
      _M_write(const char_type* __s, streamsize __n)
      {
 streamsize __put = this->rdbuf()->sputn(__s, __n);
 if (__put != __n)
   this->setstate(ios_base::badbit);
      }
# 289 "/usr/include/c++/4.1.3/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 302 "/usr/include/c++/4.1.3/ostream" 3
      __ostream_type&
      flush();
# 313 "/usr/include/c++/4.1.3/ostream" 3
      pos_type
      tellp();
# 324 "/usr/include/c++/4.1.3/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 336 "/usr/include/c++/4.1.3/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    protected:
      explicit
      basic_ostream() { }
    };
# 354 "/usr/include/c++/4.1.3/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

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

    public:
# 373 "/usr/include/c++/4.1.3/ostream" 3
      explicit
      sentry(basic_ostream<_CharT,_Traits>& __os);
# 383 "/usr/include/c++/4.1.3/ostream" 3
      ~sentry()
      {

 if (_M_os.flags() & ios_base::unitbuf && !uncaught_exception())
   {

     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
       _M_os.setstate(ios_base::badbit);
   }
      }
# 401 "/usr/include/c++/4.1.3/ostream" 3
      operator bool() const
      { return _M_ok; }
    };
# 422 "/usr/include/c++/4.1.3/ostream" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }
# 462 "/usr/include/c++/4.1.3/ostream" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s);

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s);


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<class _Traits>
    basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }
# 496 "/usr/include/c++/4.1.3/ostream" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }







  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }






  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }

}


# 1 "/usr/include/c++/4.1.3/bits/ostream.tcc" 1 3
# 43 "/usr/include/c++/4.1.3/bits/ostream.tcc" 3
       
# 44 "/usr/include/c++/4.1.3/bits/ostream.tcc" 3

# 1 "/usr/include/c++/4.1.3/locale" 1 3
# 41 "/usr/include/c++/4.1.3/locale" 3
       
# 42 "/usr/include/c++/4.1.3/locale" 3




# 1 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 1 3
# 39 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3
       
# 40 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3


# 1 "/usr/include/c++/4.1.3/typeinfo" 1 3
# 40 "/usr/include/c++/4.1.3/typeinfo" 3
#pragma GCC visibility push(default)

extern "C++" {

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






  class type_info
  {
  public:




    virtual ~type_info();

  private:

    type_info& operator=(const type_info&);
    type_info(const type_info&);

  protected:
    const char *__name;

  protected:
    explicit type_info(const char *__n): __name(__n) { }

  public:



    const char* name() const
    { return __name; }
# 105 "/usr/include/c++/4.1.3/typeinfo" 3
    bool before(const type_info& __arg) const
    { return __name < __arg.__name; }
    bool operator==(const type_info& __arg) const
    { return __name == __arg.__name; }

    bool operator!=(const type_info& __arg) const
    { return !operator==(__arg); }


  public:

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






  class bad_cast : public exception
  {
  public:
    bad_cast() throw() { }


    virtual ~bad_cast() throw();
  };


  class bad_typeid : public exception
  {
  public:
    bad_typeid () throw() { }


    virtual ~bad_typeid() throw();
  };
}

#pragma GCC visibility pop

}
# 43 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 2 3


namespace std
{
  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);
    }
# 86 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3
  template<typename _Facet>
    inline 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 && __facets[__i]);
    }
# 108 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3
  template<typename _Facet>
    inline 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 static_cast<const _Facet&>(*__facets[__i]);
    }



  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 = __null;
     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, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = __null;
     try
       {
  __tmp = new __moneypunct_cache<_CharT, _Intl>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<
   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
      }
    };

  template<typename _CharT>
    void
    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
    {
      _M_allocated = true;

      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

      _M_grouping_size = __np.grouping().size();
      char* __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>(__np.grouping()[0]) > 0);

      _M_truename_size = __np.truename().size();
      _CharT* __truename = new _CharT[_M_truename_size];
      __np.truename().copy(__truename, _M_truename_size);
      _M_truename = __truename;

      _M_falsename_size = __np.falsename().size();
      _CharT* __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);
    }

  template<typename _CharT, bool _Intl>
    void
    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
    {
      _M_allocated = true;

      const moneypunct<_CharT, _Intl>& __mp =
 use_facet<moneypunct<_CharT, _Intl> >(__loc);

      _M_grouping_size = __mp.grouping().size();
      char* __grouping = new char[_M_grouping_size];
      __mp.grouping().copy(__grouping, _M_grouping_size);
      _M_grouping = __grouping;
      _M_use_grouping = (_M_grouping_size
    && static_cast<signed char>(__mp.grouping()[0]) > 0);

      _M_decimal_point = __mp.decimal_point();
      _M_thousands_sep = __mp.thousands_sep();
      _M_frac_digits = __mp.frac_digits();

      _M_curr_symbol_size = __mp.curr_symbol().size();
      _CharT* __curr_symbol = new _CharT[_M_curr_symbol_size];
      __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
      _M_curr_symbol = __curr_symbol;

      _M_positive_sign_size = __mp.positive_sign().size();
      _CharT* __positive_sign = new _CharT[_M_positive_sign_size];
      __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
      _M_positive_sign = __positive_sign;

      _M_negative_sign_size = __mp.negative_sign().size();
      _CharT* __negative_sign = new _CharT[_M_negative_sign_size];
      __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
      _M_negative_sign = __negative_sign;

      _M_pos_format = __mp.pos_format();
      _M_neg_format = __mp.neg_format();

      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
      __ct.widen(money_base::_S_atoms,
   money_base::_S_atoms + money_base::_S_end, _M_atoms);
    }
# 271 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3
  static bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp);



  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* __q;
      const char_type* __lit_zero = __lit + __num_base::_S_izero;
      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 if ((__q = __traits_type::find(__lit_zero, 10, __c)))
     {
       __xtrc += __num_base::_S_atoms_in[__q - __lit];
       __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;
        }


      if (__testeof)
        __err |= ios_base::eofbit;
      return __beg;
    }



  template<typename _ValueT>
    struct __to_unsigned_type
    { typedef _ValueT __type; };

  template<>
    struct __to_unsigned_type<long>
    { typedef unsigned long __type; };


  template<>
    struct __to_unsigned_type<long long>
    { typedef unsigned long long __type; };




  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;
 typedef typename __to_unsigned_type<_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;
     if (numeric_limits<_ValueT>::is_signed)
       __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;
 const __unsigned_type __max = __negative ?
   -numeric_limits<_ValueT>::min() : numeric_limits<_ValueT>::max();
 const __unsigned_type __smax = __max / __base;
 __unsigned_type __result = 0;
 const char_type* __q;
 const char_type* __lit_zero = __lit + __num_base::_S_izero;
 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 if ((__q = __traits_type::find(__lit_zero, __len, __c)))
       {
  int __digit = __q - __lit_zero;
  if (__digit > 15)
    __digit -= 6;
  if (__result > __smax)
    __testfail = true;
  else
    {
      __result *= __base;
      __testfail |= __result > __max - __digit;
      __result += __digit;
      ++__sep_pos;
    }
       }
     else

       break;

     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 (!__testfail && (__sep_pos || __found_zero
       || __found_grouping.size()))
   __v = __negative ? -__result : __result;
 else
   __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, 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 = __l;
   else
            __err |= ios_base::failbit;
        }
      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;
   size_t __n;
   bool __testeof = __beg == __end;
          for (__n = 0; !__testeof; ++__n)
            {
       const char_type __c = *__beg;

       if (__testf)
  if (__n < __lc->_M_falsename_size)
    __testf = __c == __lc->_M_falsename[__n];
  else
    break;

       if (__testt)
  if (__n < __lc->_M_truename_size)
    __testt = __c == __lc->_M_truename[__n];
  else
    break;

       if (!__testf && !__testt)
  break;

       if (++__beg == __end)
  __testeof = true;
            }
   if (__testf && __n == __lc->_M_falsename_size)
     __v = 0;
   else if (__testt && __n == __lc->_M_truename_size)
     __v = 1;
   else
     __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, long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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, unsigned short& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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, unsigned int& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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, unsigned long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }


  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 long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }

  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, unsigned long long& __v) const
    { return _M_extract_int(__beg, __end, __io, __err, __v); }


  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());
      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());
      return __beg;
    }
# 796 "/usr/include/c++/4.1.3/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());
      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);

      unsigned long __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      if (!(__err & ios_base::failbit))
 __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, true);
      __len = static_cast<int>(__w);
    }






  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, long __v, const _CharT* __lit,
    ios_base::fmtflags __flags)
    {
      unsigned long __ul = __v;
      const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
      if (__builtin_expect(__basefield != ios_base::oct
      && __basefield != ios_base::hex, true))
 __ul = __v < 0 ? -__v : __ul;
      return __int_to_char(__bufend, __ul, __lit, __flags, false);
    }

  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, unsigned long __v, const _CharT* __lit,
    ios_base::fmtflags __flags)
    { return __int_to_char(__bufend, __v, __lit, __flags, false); }


  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, long long __v, const _CharT* __lit,
    ios_base::fmtflags __flags)
    {
      unsigned long long __ull = __v;
      const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
      if (__builtin_expect(__basefield != ios_base::oct
      && __basefield != ios_base::hex, true))
 __ull = __v < 0 ? -__v : __ull;
      return __int_to_char(__bufend, __ull, __lit, __flags, false);
    }

  template<typename _CharT>
    inline int
    __int_to_char(_CharT* __bufend, unsigned long long __v,
    const _CharT* __lit, ios_base::fmtflags __flags)
    { return __int_to_char(__bufend, __v, __lit, __flags, false); }



  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool)
    {
      const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
      _CharT* __buf = __bufend;

      if (__builtin_expect(__basefield != ios_base::oct
      && __basefield != ios_base::hex, true))
 {

   do
     {
       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
 }
      else if (__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
      {
 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));



 int __len = __int_to_char(__cs + __ilen, __v, __lit, __flags);
 __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;
   }


 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
 if (__builtin_expect(__basefield != ios_base::oct
        && __basefield != ios_base::hex, true))
   {

     if (__v > 0)
       {
  if (__flags & ios_base::showpos
      && numeric_limits<_ValueT>::is_signed)
    *--__cs = __lit[__num_base::_S_oplus], ++__len;
       }
     else if (__v)
       *--__cs = __lit[__num_base::_S_ominus], ++__len;
   }
 else if (__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;
    }
# 1068 "/usr/include/c++/4.1.3/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);


 streamsize __prec = __io.precision();
 if (__prec < static_cast<streamsize>(0))
   __prec = static_cast<streamsize>(6);

 const int __max_digits = numeric_limits<_ValueT>::digits10;


 int __len;

 char __fbuf[16];




 int __cs_size = __max_digits * 3;
 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));

 __num_base::_S_format_float(__io, __fbuf, __mod);
 __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
          _S_get_c_locale(), __prec);


 if (__len >= __cs_size)
   {
     __cs_size = __len + 1;
     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
     __len = std::__convert_from_v(__cs, __cs_size, __fbuf, __v,
       _S_get_c_locale(), __prec);
   }
# 1132 "/usr/include/c++/4.1.3/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);


 const _CharT __cdec = __ctype.widen('.');
 const _CharT __dec = __lc->_M_decimal_point;
 const _CharT* __p = char_traits<_CharT>::find(__ws, __len, __cdec);
 if (__p)
   __ws[__p - __ws] = __dec;




 if (__lc->_M_use_grouping
     && (__p || __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, __p, __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))
     {
       _CharT* __cs
  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
       * __w));
       _M_pad(__fill, __w, __io, __cs, __name, __len);
       __name = __cs;
     }
   __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, long __v) const
    { return _M_insert_int(__s, __io, __fill, __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long __v) const
    { return _M_insert_int(__s, __io, __fill, __v); }


  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
    { return _M_insert_int(__s, __io, __fill, __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           unsigned long long __v) const
    { return _M_insert_int(__s, __io, __fill, __v); }


  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1269 "/usr/include/c++/4.1.3/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
      | ios_base::internal);
      __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase));

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<unsigned long>(__v));
      __io.flags(__flags);
      return __s;
    }

  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || __mandatory_sign
         && (static_cast<part>(__p.field[3])
      == money_base::sign))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, ++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    {
      const char_type __c = *__beg;
      const char_type* __q = __traits_type::find(__lit_zero,
              10, __c);
      if (__q != 0)
        {
   __res += money_base::_S_atoms[__q - __lit];
   ++__n;
        }
      else if (__c == __lc->_M_decimal_point
        && !__testdecfound)
        {
   __last_pos = __n;
   __n = 0;
   __testdecfound = true;
        }
      else if (__lc->_M_use_grouping
        && __c == __lc->_M_thousands_sep
        && !__testdecfound)
        {
   if (__n)
     {

       __grouping_tmp += static_cast<char>(__n);
       __n = 0;
     }
   else
     {
       __testvalid = false;
       break;
     }
        }
      else
        break;
    }
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;
       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, ++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __err |= ios_base::failbit;
       }


     if (__testdecfound && __lc->_M_frac_digits > 0
  && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);


 if (__beg == __end)
   __err |= ios_base::eofbit;
 return __beg;
      }
# 1527 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, long double& __units) const
    {
      string __str;
      if (__intl)
 __beg = _M_extract<true>(__beg, __end, __io, __err, __str);
      else
 __beg = _M_extract<false>(__beg, __end, __io, __err, __str);
      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, string_type& __units) const
    {
      typedef typename string::size_type size_type;

      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      string __str;
      const iter_type __ret = __intl ? _M_extract<true>(__beg, __end, __io,
       __err, __str)
                              : _M_extract<false>(__beg, __end, __io,
        __err, __str);
      const size_type __len = __str.size();
      if (__len)
 {
   _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
              * __len));
   __ctype.widen(__str.data(), __str.data() + __len, __ws);
   __units.assign(__ws, __len);
 }

      return __ret;
    }

  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (!(*__beg == __lit[money_base::_S_minus]))
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     int __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
         {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
    if (__lc->_M_grouping_size)
      {
      _CharT* __ws =
          static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
             * 2 * __len));
        _CharT* __ws_end =
        std::__add_grouping(__ws, __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.assign(__ws, __ws_end - __ws);
      }
    else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
         }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }
# 1743 "/usr/include/c++/4.1.3/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    long double __units) const
    {
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __cs_size = 64;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));


      int __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
     _S_get_c_locale(), 0);

      if (__len >= __cs_size)
 {
   __cs_size = __len + 1;
   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
   __len = std::__convert_from_v(__cs, __cs_size, "%.*Lf", __units,
     _S_get_c_locale(), 0);
 }







      _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __cs_size));
      __ctype.widen(__cs, __cs + __len, __ws);
      const string_type __digits(__ws, __len);
      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    const string_type& __digits) const
    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits); }






  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      for (size_t __i = 0; __beg != __end && __i < __len && !__err; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':

    const char_type* __days1[7];
    __tp._M_days_abbreviated(__days1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
       7, __io, __err);
    break;
  case 'A':

    const char_type* __days2[7];
    __tp._M_days(__days2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
       7, __io, __err);
    break;
  case 'h':
  case 'b':

    const char_type* __months1[12];
    __tp._M_months_abbreviated(__months1);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months1, 12, __io, __err);
    break;
  case 'B':

    const char_type* __months2[12];
    __tp._M_months(__months2);
    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
       __months2, 12, __io, __err);
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __dt[0]);
    break;
  case 'd':

    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
      __io, __err);
    break;
  case 'e':


    if (__ctype.is(ctype_base::space, *__beg))
      __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
        1, __io, __err);
    else
      __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
        2, __io, __err);
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __wcs);
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
      __io, __err);
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
      __io, __err);
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __err);
    if (!__err)
      __tm->tm_mon = __mem - 1;
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
      __io, __err);
    break;
  case 'n':
    if (__ctype.narrow(*__beg, 0) == '\n')
      ++__beg;
    else
      __err |= ios_base::failbit;
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __wcs);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,



      __io, __err);
    break;
  case 't':
    if (__ctype.narrow(*__beg, 0) == '\t')
      ++__beg;
    else
      __err |= ios_base::failbit;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __wcs);
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __dates[0]);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __err,
      __tm, __times[0]);
    break;
  case 'y':
  case 'C':

    __beg = _M_extract_num(__beg, __end, __tm->tm_year, 0, 99, 2,
      __io, __err);
    break;
  case 'Y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __err);
    if (!__err)
      __tm->tm_year = __mem - 1900;
    break;
  case 'Z':

    if (__ctype.is(ctype_base::upper, *__beg))
      {
        int __tmp;
        __beg = _M_extract_name(__beg, __end, __tmp,
           __timepunct_cache<_CharT>::_S_timezones,
           14, __io, __err);


        if (__beg != __end && !__err && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __err);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __err);
   }
      }
    else
      __err |= ios_base::failbit;
    break;
  default:

    __err |= ios_base::failbit;
  }
     }
   else
     {

       if (__format[__i] == *__beg)
  ++__beg;
       else
  __err |= ios_base::failbit;
     }
 }
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
     int __min, int __max, size_t __len,
     ios_base& __io, ios_base::iostate& __err) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);

      ++__min;
      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < __len; ++__beg, ++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     {
       __value = __value * 10 + (__c - '0');
       const int __valuec = __value * __mult;
       if (__valuec > __max || __valuec + __mult < __min)
  break;
       __mult /= 10;
     }
   else
     break;
 }
      if (__i == __len)
 __member = __value;
      else
 __err |= ios_base::failbit;
      return __beg;
    }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
      const _CharT** __names, size_t __indexlen,
      ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;





      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
     if (__c == __names[__i1][0]
  || __c == __ctype.toupper(__names[__i1][0]))
       __matches[__nmatches++] = __i1;
 }

      while (__nmatches > 1)
 {

   size_t __minlen = __traits_type::length(__names[__matches[0]]);
   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
     __minlen = std::min(__minlen,
         __traits_type::length(__names[__matches[__i2]]));
   ++__beg, ++__pos;
   if (__pos < __minlen && __beg != __end)
     for (size_t __i3 = 0; __i3 < __nmatches;)
       {
  __name = __names[__matches[__i3]];
  if (!(__name[__pos] == *__beg))
    __matches[__i3] = __matches[--__nmatches];
  else
    ++__i3;
       }
   else
     break;
 }

      if (__nmatches == 1)
 {

   ++__beg, ++__pos;
   __name = __names[__matches[0]];
   const size_t __len = __traits_type::length(__name);
   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
     ++__beg, ++__pos;

   if (__len == __pos)
     __member = __matches[0];
   else
     __testvalid = false;
 }
      else
 __testvalid = false;
      if (!__testvalid)
 __err |= ios_base::failbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __times[2];
      __tp._M_time_formats(__times);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __times[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __dates[2];
      __tp._M_date_formats(__dates);
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __dates[0]);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __days[7];
      __tp._M_days_abbreviated(__days);
      int __tmpwday;
      __beg = _M_extract_name(__beg, __end, __tmpwday, __days, 7, __io, __err);







      if (!__err && __beg != __end)
 {
   size_t __pos = __traits_type::length(__days[__tmpwday]);
   __tp._M_days(__days);
   const char_type* __name = __days[__tmpwday];
   if (__name[__pos] == *__beg)
     {

       const size_t __len = __traits_type::length(__name);
       while (__pos < __len && __beg != __end
       && __name[__pos] == *__beg)
  ++__beg, ++__pos;
       if (__len != __pos)
  __err |= ios_base::failbit;
     }
 }
      if (!__err)
 __tm->tm_wday = __tmpwday;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const char_type* __months[12];
      __tp._M_months_abbreviated(__months);
      int __tmpmon;
      __beg = _M_extract_name(__beg, __end, __tmpmon, __months, 12,
         __io, __err);







      if (!__err && __beg != __end)
 {
   size_t __pos = __traits_type::length(__months[__tmpmon]);
   __tp._M_months(__months);
   const char_type* __name = __months[__tmpmon];
   if (__name[__pos] == *__beg)
     {

       const size_t __len = __traits_type::length(__name);
       while (__pos < __len && __beg != __end
       && __name[__pos] == *__beg)
  ++__beg, ++__pos;
       if (__len != __pos)
  __err |= ios_base::failbit;
     }
 }
      if (!__err)
 __tm->tm_mon = __tmpmon;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < 4; ++__beg, ++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     __value = __value * 10 + (__c - '0');
   else
     break;
 }
      if (__i == 2 || __i == 4)
 __tm->tm_year = __i == 2 ? __value : __value - 1900;
      else
 __err |= ios_base::failbit;
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
 const _CharT* __beg, const _CharT* __end) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      for (; __beg != __end; ++__beg)
 if (__ctype.narrow(*__beg, 0) != '%')
   {
     *__s = *__beg;
     ++__s;
   }
 else if (++__beg != __end)
   {
     char __format;
     char __mod = 0;
     const char __c = __ctype.narrow(*__beg, 0);
     if (__c != 'E' && __c != 'O')
       __format = __c;
     else if (++__beg != __end)
       {
  __mod = __c;
  __format = __ctype.narrow(*__beg, 0);
       }
     else
       break;
     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
   }
 else
   break;
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
    char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 128;
      char_type* __res =
       static_cast<char_type*>(__builtin_alloca(sizeof(char_type) * __maxlen));






      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
 {
   __fmt[1] = __format;
   __fmt[2] = char_type();
 }
      else
 {
   __fmt[1] = __mod;
   __fmt[2] = __format;
   __fmt[3] = char_type();
 }

      __tp._M_put(__res, __maxlen, __fmt, __tm);


      return std::__write(__s, __res, char_traits<char_type>::length(__res));
    }


  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
    { 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 __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      string_type __ret;




      for (;;)
 {

   _CharT* __c =
     static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) * __len));
   size_t __res = _M_transform(__c, __p, __len);


   if (__res >= __len)
     {
       __len = __res + 1;
       __c = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
         * __len));
       __res = _M_transform(__c, __p, __len);
     }

   __ret.append(__c, __res);
   __p += char_traits<_CharT>::length(__p);
   if (__p == __pend)
     return __ret;

   __p++;
   __ret.push_back(_CharT());
 }
    }

  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 >> (numeric_limits<unsigned long>::digits - 7)));
      return static_cast<long>(__val);
    }
# 2469 "/usr/include/c++/4.1.3/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,
       const streamsize __newlen,
       const streamsize __oldlen, const bool __num)
    {
      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, const_cast<_CharT*>(__olds), __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal && __num)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   const bool __testsign = (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0]);
   const bool __testhex = (__ctype.widen('0') == __olds[0]
      && __oldlen > 1
      && (__ctype.widen('x') == __olds[1]
          || __ctype.widen('X') == __olds[1]));
   if (__testhex)
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }
   else if (__testsign)
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, const_cast<_CharT*>(__olds + __mod),
      __oldlen - __mod);
    }

  bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp)
  {
    const size_t __n = __grouping_tmp.size() - 1;
    const size_t __min = std::min(__n, size_t(__grouping_size - 1));
    size_t __i = __n;
    bool __test = true;




    for (size_t __j = 0; __j < __min && __test; --__i, ++__j)
      __test = __grouping_tmp[__i] == __grouping[__j];
    for (; __i && __test; --__i)
      __test = __grouping_tmp[__i] == __grouping[__min];



    if (static_cast<signed char>(__grouping[__min]) > 0)
      __test &= __grouping_tmp[0] <= __grouping[__min];
    return __test;
  }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      if (__last - __first > *__gbeg
   && static_cast<signed char>(*__gbeg) > 0)
 {
   const bool __bump = __gsize != 1;
   __s = std::__add_grouping(__s, __sep, __gbeg + __bump,
        __gsize - __bump, __first,
        __last - *__gbeg);
   __first = __last - *__gbeg;
   *__s++ = __sep;
 }
      do
 *__s++ = *__first++;
      while (__first != __last);
      return __s;
    }





  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class money_get<char>;
  extern template class money_put<char>;
  extern template class numpunct<char>;
  extern template class numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;
  extern template class ctype_byname<char>;
  extern template class codecvt_byname<char, char, mbstate_t>;
  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    const collate<char>&
    use_facet<collate<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
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<collate<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
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class money_get<wchar_t>;
  extern template class money_put<wchar_t>;
  extern template class 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 __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;
  extern template class ctype_byname<wchar_t>;
  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(locale const&);

  extern template
    const collate<wchar_t>&
    use_facet<collate<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
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

 extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<collate<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&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);


}
# 47 "/usr/include/c++/4.1.3/locale" 2 3
# 46 "/usr/include/c++/4.1.3/bits/ostream.tcc" 2 3

namespace std
{
  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>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ostream_type& (*__pf)(__ostream_type&))
    {



      return __pf(*this);
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__ios_type& (*__pf)(__ios_type&))
    {



      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(ios_base& (*__pf)(ios_base&))
    {



      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(bool __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {


       long __l;
       const ios_base::fmtflags __fmt = (this->flags()
      & ios_base::basefield);
       if (__fmt == ios_base::oct || __fmt == ios_base::hex)
  __l = static_cast<long>(static_cast<unsigned short>(__n));
       else
  __l = static_cast<long>(__n);
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __l).failed())
  __err |= ios_base::badbit;
     }
   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<<(unsigned short __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {


       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(),
      static_cast<unsigned long>(__n)).failed())
  __err |= ios_base::badbit;
     }
   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<<(int __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {


       long __l;
       const ios_base::fmtflags __fmt = (this->flags()
      & ios_base::basefield);
       if (__fmt == ios_base::oct || __fmt == ios_base::hex)
  __l = static_cast<long>(static_cast<unsigned int>(__n));
       else
  __l = static_cast<long>(__n);
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __l).failed())
  __err |= ios_base::badbit;
     }
   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<<(unsigned int __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {


       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(),
      static_cast<unsigned long>(__n)).failed())
  __err |= ios_base::badbit;
     }
   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<<(long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(unsigned long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(long long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(unsigned long long __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(float __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {


       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(),
      static_cast<double>(__n)).failed())
  __err |= ios_base::badbit;
     }
   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<<(double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(long double __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(const void* __n)
    {
      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_put_type& __np = __check_facet(this->_M_num_put);
       if (__np.put(*this, *this, this->fill(), __n).failed())
  __err |= ios_base::badbit;
     }
   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<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   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::iostate(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 (...)
     { 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 (...)
     { 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::iostate(ios_base::goodbit);
      try
 {
   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
     __err |= ios_base::badbit;
 }
      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(...)
 { 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::iostate(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(...)
 { 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::iostate(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(...)
 { 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, _CharT __c)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = 1;
       _CharT* __cs = &__c;
       if (__w > __len)
  {
    __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
              * __w));
    __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
       &__c, __w, __len, false);
    __len = __w;
  }
       __out._M_write(__cs, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }


  template <class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = 1;
       char* __cs = &__c;
       if (__w > __len)
  {
    __cs = static_cast<char*>(__builtin_alloca(__w));
    __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
            &__c, __w, __len, false);
    __len = __w;
  }
       __out._M_write(__cs, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
     }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = static_cast<streamsize>(_Traits::length(__s));
       if (__w > __len)
  {
    _CharT* __cs = (static_cast<
      _CharT*>(__builtin_alloca(sizeof(_CharT)
           * __w)));
    __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
       __s, __w, __len, false);
    __s = __cs;
    __len = __w;
  }
       __out._M_write(__s, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      else if (!__s)
 __out.setstate(ios_base::badbit);
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;



      typedef char_traits<char> __traits_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
 {
   size_t __clen = __traits_type::length(__s);
   _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
              * __clen));
   for (size_t __i = 0; __i < __clen; ++__i)
     __ws[__i] = __out.widen(__s[__i]);
   _CharT* __str = __ws;

   try
     {
       const streamsize __w = __out.width();
       streamsize __len = static_cast<streamsize>(__clen);
       if (__w > __len)
  {
    _CharT* __cs = (static_cast<
      _CharT*>(__builtin_alloca(sizeof(_CharT)
           * __w)));
    __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs,
       __ws, __w, __len, false);
    __str = __cs;
    __len = __w;
  }
       __out._M_write(__str, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      else if (!__s)
 __out.setstate(ios_base::badbit);
      return __out;
    }


  template<class _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      typedef basic_ostream<char, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb && __s)
 {
   try
     {
       const streamsize __w = __out.width();
       streamsize __len = static_cast<streamsize>(_Traits::length(__s));
       if (__w > __len)
  {
    char* __cs = static_cast<char*>(__builtin_alloca(__w));
    __pad<char, _Traits>::_S_pad(__out, __out.fill(), __cs,
       __s, __w, __len, false);
    __s = __cs;
    __len = __w;
  }
       __out._M_write(__s, __len);
       __out.width(0);
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      else if (!__s)
 __out.setstate(ios_base::badbit);
      return __out;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out,
        const basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   const streamsize __w = __out.width();
   streamsize __len = static_cast<streamsize>(__str.size());
   const _CharT* __s = __str.data();



   if (__w > __len)
     {
       _CharT* __cs = (static_cast<
         _CharT*>(__builtin_alloca(sizeof(_CharT) * __w)));
       __pad<_CharT, _Traits>::_S_pad(__out, __out.fill(), __cs, __s,
          __w, __len, false);
       __s = __cs;
       __len = __w;
     }
   __out._M_write(__s, __len);
   __out.width(0);
 }
      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 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*);


}
# 526 "/usr/include/c++/4.1.3/ostream" 2 3
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include/mcrl2/exception.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include/mcrl2/exception.h"
# 1 "/usr/include/c++/4.1.3/stdexcept" 1 3
# 41 "/usr/include/c++/4.1.3/stdexcept" 3
       
# 42 "/usr/include/c++/4.1.3/stdexcept" 3




namespace std
{





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


  class invalid_argument : public logic_error
  {
  public:
    explicit invalid_argument(const string& __arg);
  };



  class length_error : public logic_error
  {
  public:
    explicit length_error(const string& __arg);
  };



  class out_of_range : public logic_error
  {
  public:
    explicit out_of_range(const string& __arg);
  };






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


  class overflow_error : public runtime_error
  {
  public:
    explicit overflow_error(const string& __arg);
  };


  class underflow_error : public runtime_error
  {
  public:
    explicit underflow_error(const string& __arg);
  };
}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include/mcrl2/exception.h" 2

# 1 "/usr/include/c++/4.1.3/iostream" 1 3
# 41 "/usr/include/c++/4.1.3/iostream" 3
       
# 42 "/usr/include/c++/4.1.3/iostream" 3



# 1 "/usr/include/c++/4.1.3/istream" 1 3
# 42 "/usr/include/c++/4.1.3/istream" 3
       
# 43 "/usr/include/c++/4.1.3/istream" 3




namespace std
{
# 57 "/usr/include/c++/4.1.3/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;

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2&);

      template<typename _CharT2, typename _Traits2>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);

    protected:







      streamsize _M_gcount;

    public:
# 103 "/usr/include/c++/4.1.3/istream" 3
      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;
# 130 "/usr/include/c++/4.1.3/istream" 3
      inline __istream_type&
      operator>>(__istream_type& (*__pf)(__istream_type&));

      inline __istream_type&
      operator>>(__ios_type& (*__pf)(__ios_type&));

      inline __istream_type&
      operator>>(ios_base& (*__pf)(ios_base&));
# 168 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      operator>>(bool& __n);

      __istream_type&
      operator>>(short& __n);

      __istream_type&
      operator>>(unsigned short& __n);

      __istream_type&
      operator>>(int& __n);

      __istream_type&
      operator>>(unsigned int& __n);

      __istream_type&
      operator>>(long& __n);

      __istream_type&
      operator>>(unsigned long& __n);


      __istream_type&
      operator>>(long long& __n);

      __istream_type&
      operator>>(unsigned long long& __n);


      __istream_type&
      operator>>(float& __f);

      __istream_type&
      operator>>(double& __f);

      __istream_type&
      operator>>(long double& __f);

      __istream_type&
      operator>>(void*& __p);
# 229 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 239 "/usr/include/c++/4.1.3/istream" 3
      inline streamsize
      gcount() const
      { return _M_gcount; }
# 271 "/usr/include/c++/4.1.3/istream" 3
      int_type
      get();
# 285 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      get(char_type& __c);
# 312 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 323 "/usr/include/c++/4.1.3/istream" 3
      inline __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 346 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 356 "/usr/include/c++/4.1.3/istream" 3
      inline __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 385 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 396 "/usr/include/c++/4.1.3/istream" 3
      inline __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 420 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      ignore();

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore(streamsize __n, int_type __delim);
# 437 "/usr/include/c++/4.1.3/istream" 3
      int_type
      peek();
# 455 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 474 "/usr/include/c++/4.1.3/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 490 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      putback(char_type __c);
# 505 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      unget();
# 523 "/usr/include/c++/4.1.3/istream" 3
      int
      sync();
# 537 "/usr/include/c++/4.1.3/istream" 3
      pos_type
      tellg();
# 552 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      seekg(pos_type);
# 568 "/usr/include/c++/4.1.3/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);


    protected:
      explicit
      basic_istream(): _M_gcount(streamsize(0)) { }
    };


  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);
# 621 "/usr/include/c++/4.1.3/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream<_CharT, _Traits>::sentry
    {
    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;
# 653 "/usr/include/c++/4.1.3/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 663 "/usr/include/c++/4.1.3/istream" 3
      operator bool() const { return _M_ok; }

    private:
      bool _M_ok;
    };
# 682 "/usr/include/c++/4.1.3/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }
# 723 "/usr/include/c++/4.1.3/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>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }

  template<class _Traits>
    basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
    { return (__in >> reinterpret_cast<char*>(__s)); }
# 750 "/usr/include/c++/4.1.3/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(), __ostream_type()
      { this->init(__sb); }




      virtual
      ~basic_iostream() { }

    protected:
      explicit
      basic_iostream() : __istream_type(), __ostream_type()
      { }
    };
# 813 "/usr/include/c++/4.1.3/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
}


# 1 "/usr/include/c++/4.1.3/bits/istream.tcc" 1 3
# 43 "/usr/include/c++/4.1.3/bits/istream.tcc" 3
       
# 44 "/usr/include/c++/4.1.3/bits/istream.tcc" 3




namespace std
{
  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::iostate(ios_base::goodbit);
      if (__in.good())
 {
   if (__in.tie())
     __in.tie()->flush();
   if (!__noskip && (__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>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__istream_type& (*__pf)(__istream_type&))
    { return __pf(*this); }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__ios_type& (*__pf)(__ios_type&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(ios_base& (*__pf)(ios_base&))
    {
      __pf(*this);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(bool& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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::iostate(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 (!(__err & ios_base::failbit)
    && (numeric_limits<short>::min() <= __l
        && __l <= numeric_limits<short>::max()))
  __n = __l;
       else
                __err |= ios_base::failbit;
     }
   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>>(unsigned short& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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::iostate(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 (!(__err & ios_base::failbit)
    && (numeric_limits<int>::min() <= __l
        && __l <= numeric_limits<int>::max()))
  __n = __l;
       else
                __err |= ios_base::failbit;
     }
   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>>(unsigned int& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(unsigned long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(long long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(unsigned long long& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(float& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(long double& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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>>(void*& __n)
    {
      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       const __num_get_type& __ng = __check_facet(this->_M_num_get);
       __ng.get(*this, 0, *this, __err, __n);
     }
   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::iostate(ios_base::goodbit);
      sentry __cerb(*this, false);
      if (__cerb && __sbout)
 {
   try
     {
       if (!__copy_streambufs(this->rdbuf(), __sbout))
  __err |= ios_base::failbit;
     }
   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::iostate(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(...)
     { 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::iostate(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(...)
     { 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::iostate(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(...)
     { 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::iostate(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(...)
     { 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::iostate(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(...)
            { 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::iostate(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(...)
     { 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::iostate(ios_base::goodbit);
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
# 692 "/usr/include/c++/4.1.3/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 == numeric_limits<streamsize>::max()
        && !traits_type::eq_int_type(__c, __eof))
      {
        _M_gcount = numeric_limits<streamsize>::min();
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = numeric_limits<streamsize>::max();

       if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
            }
          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::iostate(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 == numeric_limits<streamsize>::max()
        && !traits_type::eq_int_type(__c, __eof)
        && !traits_type::eq_int_type(__c, __delim))
      {
        _M_gcount = numeric_limits<streamsize>::min();
        __large_ignore = true;
      }
    else
      break;
  }

       if (__large_ignore)
  _M_gcount = numeric_limits<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 < numeric_limits<streamsize>::max())
      ++_M_gcount;
    __sb->sbumpc();
  }
            }
          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::iostate(ios_base::goodbit);
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   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::iostate(ios_base::goodbit);
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   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::iostate(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(...)
     { 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;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(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(...)
     { 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;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::iostate(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(...)
     { 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::iostate(ios_base::goodbit);
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   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);
      try
 {
   if (!this->fail())
     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::in);
 }
      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)
    {


      ios_base::iostate __err = ios_base::iostate(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(...)
 { 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)
    {


      ios_base::iostate __err = ios_base::iostate(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(...)
 { 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::iostate(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(...)
     { __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 typename __istream_type::__streambuf_type __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::iostate(ios_base::goodbit);
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       streamsize __num = __in.width();
       if (__num <= 0)
  __num = numeric_limits<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(...)
     { __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 typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename __istream_type::int_type __int_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;
    }


  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 typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      ios_base::iostate __err = ios_base::iostate(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();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->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 = __sb->snextc();
  }
       __str.append(__buf, __len);

       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
       __in.width(0);
     }
   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 typename __istream_type::int_type __int_type;
      typedef typename __istream_type::__streambuf_type __streambuf_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      ios_base::iostate __err = ios_base::iostate(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();
       __streambuf_type* __sb = __in.rdbuf();
       __int_type __c = __sb->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    __str += _Traits::to_char_type(__c);
    ++__extracted;
    __c = __sb->snextc();
  }

       if (_Traits::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __sb->sbumpc();
  }
       else
  __err |= ios_base::failbit;
     }
   catch(...)
     {



       __in._M_setstate(ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<class _CharT, class _Traits, class _Alloc>
    inline basic_istream<_CharT,_Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT,_Traits,_Alloc>& __str)
    { return getline(__in, __str, __in.widen('\n')); }





  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 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 class basic_iostream<wchar_t>;


}
# 820 "/usr/include/c++/4.1.3/istream" 2 3
# 46 "/usr/include/c++/4.1.3/iostream" 2 3

namespace std
{
# 62 "/usr/include/c++/4.1.3/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;
}
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include/mcrl2/exception.h" 2
# 1 "/usr/include/c++/4.1.3/cassert" 1 3
# 47 "/usr/include/c++/4.1.3/cassert" 3
       
# 48 "/usr/include/c++/4.1.3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 49 "/usr/include/c++/4.1.3/cassert" 2 3
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include/mcrl2/exception.h" 2

namespace mcrl2 {




  class runtime_error : public std::runtime_error {

    private:

      std::string m_message;

    public:



      runtime_error(std::string const& message) : std::runtime_error(message), m_message(std::string("error: ").append(message)) {
      }


      const char* what() const throw () {
        return m_message.c_str();
      }

      ~runtime_error() throw () {
      }
  };




  class logic_error : public std::logic_error {

    private:

      std::string m_message;

    public:



      logic_error(std::string const& message) : std::logic_error(message), m_message(std::string("error: ").append(message)) {
      }


      const char* what() const throw () {
        return m_message.c_str();
      }

      ~logic_error() throw () {
      }
  };
}
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h"
# 1 "/usr/include/c++/4.1.3/cassert" 1 3
# 47 "/usr/include/c++/4.1.3/cassert" 3
       
# 48 "/usr/include/c++/4.1.3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 49 "/usr/include/c++/4.1.3/cassert" 2 3
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h" 1
# 14 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h" 1
# 65 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
# 1 "/usr/lib/gcc/x86_64-linux-gnu/4.1.3/include/stdarg.h" 1 3 4
# 66 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/encoding.h" 1






# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/atypes.h" 1



# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/abool.h" 1




extern "C"
{


typedef enum { ATfalse=0, ATtrue } ATbool;


}
# 5 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/atypes.h" 2


extern "C"
{


typedef unsigned int ShortHashNumber;

typedef long MachineWord;
typedef unsigned long HashNumber;
# 25 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/atypes.h"
}
# 8 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/encoding.h" 2
# 18 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/encoding.h"
extern "C"
{
# 43 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/encoding.h"
typedef unsigned long header_type;
# 177 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/encoding.h"
struct __ATerm
{
  header_type header;
  union _ATerm *next;
};

typedef union _ATerm
{
  header_type header;
  struct __ATerm aterm;
  union _ATerm* subaterm[1];
  MachineWord word[1];
} *ATerm;

typedef void (*ATermProtFunc)();


}
# 67 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h" 2




extern "C"
{
# 90 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
ATerm ATsetAnnotation(ATerm t, ATerm label, ATerm anno);
ATerm ATgetAnnotation(ATerm t, ATerm label);
ATerm ATremoveAnnotation(ATerm t, ATerm label);
# 118 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
ATerm ATmake(const char *pattern, ...);
# 142 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
ATbool ATmatch(ATerm t, const char *pattern, ...);





ATerm ATmakeTerm(ATerm pat, ...);





ATbool ATmatchTerm(ATerm t, ATerm pat, ...);


ATerm ATvmake(const char *pat);


ATerm ATvmakeTerm(ATerm pat);


void AT_vmakeSetArgs(va_list *args);


ATbool ATvmatch(ATerm t, const char *pat);


ATbool ATvmatchTerm(ATerm t, ATerm pat);


extern ATbool AT_isEqual(ATerm t1, ATerm t2);
extern ATbool AT_isDeepEqual(ATerm t1, ATerm t2);
# 192 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
ATbool ATisEqualModuloAnnotations(ATerm t1, ATerm t2);





ATbool ATwriteToTextFile(ATerm t, FILE *file);






long ATwriteToSharedTextFile(ATerm t, FILE *f);

ATbool ATwriteToBinaryFile(ATerm t, FILE *file);






ATbool ATwriteToNamedTextFile(ATerm t, const char *name);






ATbool ATwriteToNamedSharedTextFile(ATerm t, const char *name);






ATbool ATwriteToNamedBinaryFile(ATerm t, const char *name);






char *ATwriteToString(ATerm t);
# 245 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
char *ATwriteToSharedString(ATerm t, int *len);
# 254 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
unsigned char *ATwriteToBinaryString(ATerm t, int *len);





ATerm ATreadFromTextFile(FILE *file);





ATerm ATreadFromSharedTextFile(FILE *f);






ATerm ATreadFromBinaryFile(FILE *file);





ATerm ATreadFromFile(FILE *file);






ATerm ATreadFromNamedFile(const char *name);






ATerm ATreadFromString(const char *string);






ATerm ATreadFromSharedString(const char *s, int size);






ATerm ATreadFromBinaryString(const unsigned char *s, int size);



ATbool ATwriteToSAFFile(ATerm aTerm, FILE *file);

ATerm ATreadFromSAFFile(FILE *file);

ATbool ATwriteToNamedSAFFile(ATerm aTerm, const char *filename);

ATerm ATreadFromNamedSAFFile(const char *filename);

char* ATwriteToSAFString(ATerm aTerm, int *length);

ATerm ATreadFromSAFString(char *data, int length);
# 331 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
void ATprotect(ATerm *atp);





void ATunprotect(ATerm *atp);






void ATprotectArray(ATerm *start, unsigned int size);





void ATunprotectArray(ATerm *start);
# 363 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
void ATaddProtectFunction(ATermProtFunc f);




void ATremoveProtectFunction(ATermProtFunc f);







void ATmarkTerm(ATerm t);
# 385 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
void ATmarkArray(ATerm *start, int size);
# 416 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
void ATinit(int argc, char *argv[], ATerm *bottomOfStack);




void ATinitialize(int argc, char *argv[]);





ATbool ATisInitialized();





void ATsetWarningHandler(void (*handler)(const char *format, va_list args));





void ATsetErrorHandler(void (*handler)(const char *format, va_list args));





void ATsetAbortHandler(void (*handler)(const char *format, va_list args));







void ATwarning(const char *format, ...);
# 462 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
void ATerror(const char *format, ...);
# 471 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
void ATabort(const char *format, ...);





int ATprintf(const char *format, ...);
# 490 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm1.h"
int ATfprintf(FILE *stream, const char *format, ...);




int ATvfprintf(FILE *stream, const char *format, va_list args);


}
# 15 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/afun.h" 1
# 9 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/afun.h"
extern "C"
{
# 23 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/afun.h"
typedef MachineWord AFun;


typedef struct _SymEntry
{
  header_type header;
  struct _SymEntry *next;
  AFun id;
  char *name;
  int count;
  int index;
} *SymEntry;
# 45 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/afun.h"
union _ATerm;
extern union _ATerm **at_lookup_table_alias;
extern SymEntry *at_lookup_table;

unsigned long AT_symbolTableSize();
void AT_initSymbol(int argc, char *argv[]);
int AT_printSymbol(AFun sym, FILE *f);







void AT_freeSymbol(SymEntry sym);
void AT_markProtectedSymbols();
void AT_markProtectedSymbols_young();

unsigned int AT_hashSymbol(const char *name, int arity);
ATbool AT_findSymbol(char *name, int arity, ATbool quoted);
void AT_unmarkAllAFuns();


}
# 16 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h" 2



extern "C"
{
# 29 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
struct __ATermInt
{
  header_type header;
  ATerm next;
  long value;
};

typedef union _ATermInt
{
  header_type header;
  struct __ATermInt aterm;
} *ATermInt;

struct __ATermReal
{
  header_type header;
  ATerm next;
  double value;
};

typedef union _ATermReal
{
  header_type header;
  struct __ATermReal aterm;
} *ATermReal;

struct __ATermAppl
{
  header_type header;
  ATerm next;
  ATerm arg[1];
};

typedef union _ATermAppl
{
  header_type header;
  struct __ATermAppl aterm;
} *ATermAppl;

struct __ATermList
{
  header_type header;
  ATerm next;
  ATerm head;
  union _ATermList *tail;
};

typedef union _ATermList
{
  header_type header;
  struct __ATermList aterm;
} *ATermList;

struct __ATermPlaceholder
{
  header_type header;
  ATerm next;
  ATerm ph_type;
};

typedef union _ATermPlaceholder
{
  header_type header;
  struct __ATermPlaceholder aterm;
} *ATermPlaceholder;

struct __ATermBlob
{
  header_type header;
  ATerm next;
  unsigned long size;
  void *data;
};

typedef union _ATermBlob
{
  header_type header;
  struct __ATermBlob aterm;
} *ATermBlob;

struct _ATermTable;

typedef struct _ATermTable *ATermIndexedSet;
typedef struct _ATermTable *ATermTable;
# 122 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
ATermInt ATmakeInt(int value);




ATermReal ATmakeReal(double value);




ATermAppl ATmakeAppl(AFun sym, ...);
ATermAppl ATmakeAppl0(AFun sym);
ATermAppl ATmakeAppl1(AFun sym, ATerm arg0);
ATermAppl ATmakeAppl2(AFun sym, ATerm arg0, ATerm arg1);
ATermAppl ATmakeAppl3(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2);
ATermAppl ATmakeAppl4(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2,
         ATerm arg3);
ATermAppl ATmakeAppl5(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2,
         ATerm arg4, ATerm arg5);
ATermAppl ATmakeAppl6(AFun sym, ATerm arg0, ATerm arg1, ATerm arg2,
         ATerm arg4, ATerm arg5, ATerm arg6);







ATermAppl ATsetArgument(ATermAppl appl, ATerm arg, unsigned int n);


ATermList ATgetArguments(ATermAppl appl);
ATermAppl ATmakeApplList(AFun sym, ATermList args);
ATermAppl ATmakeApplArray(AFun sym, ATerm args[]);


extern ATermList ATempty;

ATermList ATmakeList(unsigned int n, ...);




ATermList ATmakeList1(ATerm el0);
# 177 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
unsigned int ATgetLength(ATermList list);
# 189 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
ATermList ATgetTail(ATermList list, int start);
ATermList ATreplaceTail(ATermList list, ATermList newtail, int start);
ATermList ATgetPrefix(ATermList list);
ATerm ATgetLast(ATermList list);
ATermList ATgetSlice(ATermList list, unsigned int start, unsigned int end);
ATermList ATinsert(ATermList list, ATerm el);
ATermList ATinsertAt(ATermList list, ATerm el, unsigned int index);
ATermList ATappend(ATermList list, ATerm el);
ATermList ATconcat(ATermList list1, ATermList list2);
int ATindexOf(ATermList list, ATerm el, int start);
int ATlastIndexOf(ATermList list, ATerm el, int start);
ATerm ATelementAt(ATermList list, unsigned int index);
ATermList ATremoveElement(ATermList list, ATerm el);
ATermList ATremoveElementAt(ATermList list, unsigned int idx);
ATermList ATremoveAll(ATermList list, ATerm el);
ATermList ATreplace(ATermList list, ATerm el, unsigned int idx);
ATermList ATreverse(ATermList list);
ATermList ATsort(ATermList list, int (*compare)(const ATerm t1, const ATerm t2));
int ATcompare(ATerm t1, ATerm t2);
ATerm ATdictCreate();
ATerm ATdictGet(ATerm dict, ATerm key);
ATerm ATdictPut(ATerm dict, ATerm key, ATerm value);
ATerm ATdictRemove(ATerm dict, ATerm key);

ATermTable ATtableCreate(long initial_size, int max_load_pct);
void ATtableDestroy(ATermTable table);
void ATtableReset(ATermTable table);
void ATtablePut(ATermTable table, ATerm key, ATerm value);
ATerm ATtableGet(ATermTable table, ATerm key);
void ATtableRemove(ATermTable table, ATerm key);
ATermList ATtableKeys(ATermTable table);
ATermList ATtableValues(ATermTable table);

ATermIndexedSet
           ATindexedSetCreate(long initial_size, int max_load_pct);
void ATindexedSetDestroy(ATermIndexedSet set);
void ATindexedSetReset(ATermIndexedSet set);
long ATindexedSetPut(ATermIndexedSet set, ATerm elem, ATbool *isnew);
long ATindexedSetGetIndex(ATermIndexedSet set, ATerm elem);
void ATindexedSetRemove(ATermIndexedSet set, ATerm elem);
ATermList ATindexedSetElements(ATermIndexedSet set);
ATerm ATindexedSetGetElem(ATermIndexedSet set, long index);


ATermList ATfilter(ATermList list, ATbool (*predicate)(ATerm));


ATermPlaceholder ATmakePlaceholder(ATerm type);




ATermBlob ATmakeBlob(unsigned int size, void *data);






void ATregisterBlobDestructor(ATbool (*destructor)(ATermBlob));
void ATunregisterBlobDestructor(ATbool (*destructor)(ATermBlob));

AFun ATmakeAFun(const char *name, int arity, ATbool quoted);
# 261 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
void ATprotectAFun(AFun sym);

void ATunprotectAFun(AFun sym);

void ATprotectMemory(void *start, unsigned long size);
void ATunprotectMemory(void *start);






ATerm AT_getAnnotations(ATerm t);
ATerm AT_setAnnotations(ATerm t, ATerm annos);
ATerm AT_removeAnnotations(ATerm t);


ATerm ATremoveAllAnnotations(ATerm t);




unsigned char *ATchecksum(ATerm t);
ATbool ATdiff(ATerm t1, ATerm t2, ATerm *templ, ATerm *diffs);
# 294 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h"
int ATcompare(ATerm t1, ATerm t2);

void ATsetChecking(ATbool on);
ATbool ATgetChecking(void);


extern int at_gc_count;


unsigned long ATcalcUniqueSubterms(ATerm t);
unsigned long ATcalcUniqueSymbols(ATerm t);

unsigned long ATcalcTextSize(ATerm t);

void AT_writeToStringBuffer(ATerm t, char *buffer);





}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_traits.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_traits.h"
# 1 "/usr/include/boost/utility/enable_if.hpp" 1 3 4
# 24 "/usr/include/boost/utility/enable_if.hpp" 3 4
namespace boost
{

  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };

  template <class T>
  struct enable_if_c<false, T> {};

  template <class Cond, class T = void>
  struct enable_if : public enable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_enable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_enable_if_c<false, T> {};

  template <class Cond, class T>
  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};


  template <bool B, class T = void>
  struct disable_if_c {
    typedef T type;
  };

  template <class T>
  struct disable_if_c<true, T> {};

  template <class Cond, class T = void>
  struct disable_if : public disable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_disable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_disable_if_c<true, T> {};

  template <class Cond, class T>
  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_traits.h" 2
# 1 "/usr/include/boost/type_traits/is_base_of.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/is_base_of.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
# 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
# 1 "/usr/include/boost/type_traits/config.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/config.hpp" 3 4
# 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/config.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/is_class.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_union.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_union.hpp" 3 4
# 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
# 1 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 2 3 4
# 95 "/usr/include/boost/type_traits/broken_compiler_spec.hpp" 3 4















# 15 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 1 3 4
# 23 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
namespace boost {
namespace detail {







template <typename T> struct cv_traits_imp {};

template <typename T>
struct cv_traits_imp<T*>
{
    static const bool is_const = false;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const T*>
{
    static const bool is_const = true;
    static const bool is_volatile = false;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<volatile T*>
{
    static const bool is_const = false;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};

template <typename T>
struct cv_traits_imp<const volatile T*>
{
    static const bool is_const = true;
    static const bool is_volatile = true;
    typedef T unqualified_type;
};
# 92 "/usr/include/boost/type_traits/detail/cv_traits_impl.hpp" 3 4
}
}
# 16 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
# 26 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 10 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 3 4
# 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/int.hpp" 3 4
# 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
# 18 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4

namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/usr/include/boost/mpl/int.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 16 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
# 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4

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




# 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/cat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/cat.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 2 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< int N >
struct int_
{
    static const int value = N;





    typedef int_ type;

    typedef int value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;






    operator int() const { return static_cast<int>(this->value); }
};


template< int N >
int const mpl_::int_< N >::value;


}
# 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
# 11 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 12 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/comma_if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 16 "/usr/include/boost/preprocessor/comma_if.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/repeat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 16 "/usr/include/boost/preprocessor/repeat.hpp" 2 3 4
# 47 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/inc.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/inc.hpp" 2 3 4
# 48 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4

namespace boost {




template< typename T > struct remove_cv { typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type; };
template< typename T > struct remove_cv<T&> { typedef T& type; };

template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };
# 57 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 60 "/usr/include/boost/type_traits/remove_cv.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4




# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
# 10 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
# 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/bool.hpp" 3 4
# 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
namespace mpl_ {

template< bool C_ > struct bool_;


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

}

namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
# 18 "/usr/include/boost/mpl/bool.hpp" 2 3 4



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 "/usr/include/boost/type_traits/integral_constant.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/integral_c.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/usr/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/integral_c_fwd.hpp" 3 4
namespace mpl_ {





template< typename T, T N > struct integral_c;


}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
# 18 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< typename T, T N >
struct integral_c
{
    static const T value = N;





    typedef integral_c type;

    typedef T value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    typedef integral_c< T, static_cast<T>((value + 1)) > next;
    typedef integral_c< T, static_cast<T>((value - 1)) > prior;






    operator T() const { return static_cast<T>(this->value); }
};


template< typename T, T N >
T const integral_c< T, N >::value;


}
# 33 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4




namespace mpl_ {

template< bool C >
struct integral_c<bool, C>
{
    static const bool value = C;
    typedef integral_c_tag tag;
    typedef integral_c type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};
}
# 12 "/usr/include/boost/type_traits/integral_constant.hpp" 2 3 4

namespace boost{




template <class T, T val>

struct integral_constant : public mpl::integral_c<T, val>
{
   typedef integral_constant<T,val> type;
};

template<> struct integral_constant<bool,true> : public mpl::true_
{







   typedef integral_constant<bool,true> type;
};
template<> struct integral_constant<bool,false> : public mpl::false_
{







   typedef integral_constant<bool,false> type;
};

typedef integral_constant<bool,true> true_type;
typedef integral_constant<bool,false> false_type;

}
# 16 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4

namespace boost {

namespace detail {
# 36 "/usr/include/boost/type_traits/is_union.hpp" 3 4
template <typename T> struct is_union_impl
{
   static const bool value = false;
};

}

template< typename T > struct is_union : ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 48 "/usr/include/boost/type_traits/is_union.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_and.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/ice_and.hpp" 3 4
namespace boost {
namespace type_traits {

template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
struct ice_and;

template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_and
{
    static const bool value = false;
};

template <>
struct ice_and<true, true, true, true, true, true, true>
{
    static const bool value = true;
};

}
}
# 18 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_not.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/detail/ice_not.hpp" 3 4
namespace boost {
namespace type_traits {

template <bool b>
struct ice_not
{
    static const bool value = true;
};

template <>
struct ice_not<true>
{
    static const bool value = false;
};

}
}
# 19 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 3 4
namespace boost {
namespace type_traits {

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

}
}
# 22 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
# 37 "/usr/include/boost/type_traits/is_class.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 38 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4

namespace boost {

namespace detail {
# 58 "/usr/include/boost/type_traits/is_class.hpp" 3 4
template <class U> ::boost::type_traits::yes_type is_class_tester(void(U::*)(void));
template <class U> ::boost::type_traits::no_type is_class_tester(...);

template <typename T>
struct is_class_impl
{

    static const bool value = (::boost::type_traits::ice_and< sizeof(is_class_tester<T>(0)) == sizeof(::boost::type_traits::yes_type), ::boost::type_traits::ice_not< ::boost::is_union<T>::value >::value >::value);





};
# 127 "/usr/include/boost/type_traits/is_class.hpp" 3 4
}





template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 139 "/usr/include/boost/type_traits/is_class.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_same.hpp" 1 3 4
# 31 "/usr/include/boost/type_traits/is_same.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 32 "/usr/include/boost/type_traits/is_same.hpp" 2 3 4

namespace boost {



template< typename T, typename U > struct is_same : ::boost::integral_constant<bool,false> { };
template< typename T > struct is_same< T,T > : ::boost::integral_constant<bool,true> { };
# 98 "/usr/include/boost/type_traits/is_same.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 101 "/usr/include/boost/type_traits/is_same.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_convertible.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_array.hpp" 1 3 4
# 27 "/usr/include/boost/type_traits/is_array.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 28 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4

namespace boost {




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

template< typename T, std::size_t N > struct is_array< T[N] > : ::boost::integral_constant<bool,true> { };
template< typename T, std::size_t N > struct is_array< T const[N] > : ::boost::integral_constant<bool,true> { };
template< typename T, std::size_t N > struct is_array< T volatile[N] > : ::boost::integral_constant<bool,true> { };
template< typename T, std::size_t N > struct is_array< T const volatile[N] > : ::boost::integral_constant<bool,true> { };

template< typename T > struct is_array< T[] > : ::boost::integral_constant<bool,true> { };
template< typename T > struct is_array< T const[] > : ::boost::integral_constant<bool,true> { };
template< typename T > struct is_array< T volatile[] > : ::boost::integral_constant<bool,true> { };
template< typename T > struct is_array< T const volatile[] > : ::boost::integral_constant<bool,true> { };
# 87 "/usr/include/boost/type_traits/is_array.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 90 "/usr/include/boost/type_traits/is_array.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_reference.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_reference.hpp" 1 3 4
# 32 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 33 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4

namespace boost {





template< typename T > struct is_reference : ::boost::integral_constant<bool,false> { };
template< typename T > struct is_reference< T& > : ::boost::integral_constant<bool,true> { };
# 113 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 116 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4




# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4

namespace boost {

namespace detail {
# 55 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
template <typename T>
struct add_reference_impl
{
    typedef T& type;
};


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





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

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


}

template< typename T > struct add_reference { typedef typename boost::detail::add_reference_impl<T>::type type; };







}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 88 "/usr/include/boost/type_traits/add_reference.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/ice.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/ice.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/ice_or.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/detail/ice_or.hpp" 3 4
namespace boost {
namespace type_traits {

template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
struct ice_or;

template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
struct ice_or
{
    static const bool value = true;
};

template <>
struct ice_or<false, false, false, false, false, false, false>
{
    static const bool value = false;
};

}
}
# 16 "/usr/include/boost/type_traits/ice.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/detail/ice_eq.hpp" 3 4
namespace boost {
namespace type_traits {

template <int b1, int b2>
struct ice_eq
{
    static const bool value = (b1 == b2);
};

template <int b1, int b2>
struct ice_ne
{
    static const bool value = (b1 != b2);
};


template <int b1, int b2> bool const ice_eq<b1,b2>::value;
template <int b1, int b2> bool const ice_ne<b1,b2>::value;


}
}
# 19 "/usr/include/boost/type_traits/ice.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_arithmetic.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_integral.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/is_integral.hpp" 2 3 4

namespace boost {







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

template<> struct is_integral< unsigned char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< unsigned short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< unsigned int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< unsigned long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const volatile > : ::boost::integral_constant<bool,true> { };

template<> struct is_integral< signed char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< signed short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< signed int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< signed long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const volatile > : ::boost::integral_constant<bool,true> { };

template<> struct is_integral< bool > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const volatile > : ::boost::integral_constant<bool,true> { };





template<> struct is_integral< wchar_t > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const volatile > : ::boost::integral_constant<bool,true> { };
# 65 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
template<> struct is_integral< ::boost::ulong_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_integral< ::boost::long_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const volatile > : ::boost::integral_constant<bool,true> { };







}

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

namespace boost {


template< typename T > struct is_float : ::boost::integral_constant<bool,false> { };
template<> struct is_float< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_float< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_float< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const volatile > : ::boost::integral_constant<bool,true> { };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_float.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4

namespace boost {


namespace detail {

template< typename T >
struct is_arithmetic_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value);




};

}






template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 50 "/usr/include/boost/type_traits/is_arithmetic.hpp" 2 3 4
# 23 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_void.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_void.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/is_void.hpp" 2 3 4

namespace boost {





template< typename T > struct is_void : ::boost::integral_constant<bool,false> { };
template<> struct is_void< void > : ::boost::integral_constant<bool,true> { };


template<> struct is_void< void const > : ::boost::integral_constant<bool,true> { };
template<> struct is_void< void volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_void< void const volatile > : ::boost::integral_constant<bool,true> { };




}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 37 "/usr/include/boost/type_traits/is_void.hpp" 2 3 4
# 24 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/is_abstract.hpp" 1 3 4
# 53 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
# 1 "/usr/include/boost/static_assert.hpp" 1 3 4
# 45 "/usr/include/boost/static_assert.hpp" 3 4
namespace boost{


template <bool x> struct STATIC_ASSERTION_FAILURE;

template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };


template<int x> struct static_assert_test{};

}
# 54 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
# 62 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 63 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4


namespace boost {
namespace detail{
# 75 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
template<class T>
struct is_abstract_imp2
{




   template<class U>
   static type_traits::no_type check_sig(U (*)[1]);
   template<class U>
   static type_traits::yes_type check_sig(...);




   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(T) != 0) == 0 ? false : true) >)> boost_static_assert_typedef_90;




   static const std::size_t s1 = sizeof(is_abstract_imp2<T>::template check_sig<T>(0));
# 107 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
   static const bool value = (s1 == sizeof(type_traits::yes_type));

};

template <bool v>
struct is_abstract_select
{
   template <class T>
   struct rebind
   {
      typedef is_abstract_imp2<T> type;
   };
};
template <>
struct is_abstract_select<false>
{
   template <class T>
   struct rebind
   {
      typedef false_type type;
   };
};

template <class T>
struct is_abstract_imp
{
   typedef is_abstract_select< ::boost::is_class<T>::value> selector;
   typedef typename selector::template rebind<T> binder;
   typedef typename binder::type type;

   static const bool value = type::value;
};


}


template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { };




}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 152 "/usr/include/boost/type_traits/is_abstract.hpp" 2 3 4
# 26 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 36 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 37 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4

namespace boost {
# 52 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
namespace detail {
# 119 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
struct any_conversion
{
    template <typename T> any_conversion(const volatile T&);
    template <typename T> any_conversion(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 From _m_from;
    static bool const value = sizeof( detail::checker<To>::_m_check(_m_from, 0) )
        == sizeof(::boost::type_traits::yes_type);
};
# 291 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
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 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
};


template <bool trivial1, bool trivial2, bool abstract_target>
struct is_convertible_impl_select
{
   template <class From, class To>
   struct rebind
   {
      typedef is_convertible_impl<From, To> type;
   };
};

template <>
struct is_convertible_impl_select<true, true, false>
{
   template <class From, class To>
   struct rebind
   {
      typedef true_type type;
   };
};

template <>
struct is_convertible_impl_select<false, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <>
struct is_convertible_impl_select<true, false, true>
{
   template <class From, class To>
   struct rebind
   {
      typedef false_type type;
   };
};

template <typename From, typename To>
struct is_convertible_impl_dispatch_base
{

   typedef is_convertible_impl_select<
      ::boost::is_arithmetic<From>::value,
      ::boost::is_arithmetic<To>::value,

      ::boost::is_abstract<To>::value



   > selector;



   typedef typename selector::template rebind<From, To> isc_binder;
   typedef typename isc_binder::type type;
};

template <typename From, typename To>
struct is_convertible_impl_dispatch
   : public is_convertible_impl_dispatch_base<From, To>::type
{};
# 394 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
    template<> struct is_convertible_impl< void,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { static const bool value = (true); };
# 404 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
template< typename To > struct is_convertible_impl< void,To > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void > { static const bool value = (true); };

template< typename To > struct is_convertible_impl< void const,To > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void volatile,To > { static const bool value = (false); };
template< typename To > struct is_convertible_impl< void const volatile,To > { static const bool value = (false); };
template< typename From > struct is_convertible_impl< From,void const > { static const bool value = (true); };
template< typename From > struct is_convertible_impl< From,void volatile > { static const bool value = (true); };
template< typename From > struct is_convertible_impl< From,void const volatile > { static const bool value = (true); };



}

template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { };







}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 429 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4







# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 25 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4

namespace boost {

namespace detail {
# 115 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
template <typename B, typename D>
struct bd_helper
{






    template <typename T>
    static type_traits::yes_type check_sig(D const volatile *, T);
    static type_traits::no_type check_sig(B const volatile *, int);




};

template<typename B, typename D>
struct is_base_and_derived_impl2
{
# 144 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(B) != 0) == 0 ? false : true) >)> boost_static_assert_typedef_144;
    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((sizeof(D) != 0) == 0 ? false : true) >)> boost_static_assert_typedef_145;

    struct Host
    {

        operator B const volatile *() const;



        operator D const volatile *();
    };

    static const bool value = sizeof(bd_helper<B,D>::check_sig(Host(), 0)) == sizeof(type_traits::yes_type);




};
# 180 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
template <typename B, typename D>
struct is_base_and_derived_impl3
{
    static const bool value = false;
};

template <bool ic1, bool ic2, bool iss>
struct is_base_and_derived_select
{
   template <class T, class U>
   struct rebind
   {
      typedef is_base_and_derived_impl3<T,U> type;
   };
};

template <>
struct is_base_and_derived_select<true,true,false>
{
   template <class T, class U>
   struct rebind
   {
      typedef is_base_and_derived_impl2<T,U> type;
   };
};

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;

    typedef is_base_and_derived_select<
       ::boost::is_class<B>::value,
       ::boost::is_class<D>::value,
       ::boost::is_same<B,D>::value> selector;
    typedef typename selector::template rebind<ncvB,ncvD> binder;
    typedef typename binder::type bound_type;

    static const bool value = bound_type::value;
};







}

template< typename Base, typename Derived > struct is_base_and_derived : ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { };







template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : ::boost::integral_constant<bool,false> { };






}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 250 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 2 3 4
# 13 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4




# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 18 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4

namespace boost {

template< typename Base, typename Derived > struct is_base_of : ::boost::integral_constant<bool,(::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<Base,Derived>::value), (::boost::is_same<Base,Derived>::value)>::value)> { };
# 31 "/usr/include/boost/type_traits/is_base_of.hpp" 3 4
template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : ::boost::integral_constant<bool,false> { };
template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : ::boost::integral_constant<bool,false> { };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 39 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_traits.h" 2



namespace atermpp {

class aterm;

template < typename T >
struct non_aterm_traits
{

  typedef void* aterm_type;



  static void protect(T*) {}



  static void unprotect(T*) {}



  static void mark(T) {}




  static T term(const T& t)
  { return t; }




  static const T* ptr(const T& t)
  { return &t; }
};

template < typename T, typename C = void >
struct select_traits_base {
  typedef non_aterm_traits< T > base_type;
};



template <typename T>
struct aterm_traits: public select_traits_base< T >::base_type
{};


template <>
struct aterm_traits<ATerm>
{
  typedef ATerm aterm_type;
  static void protect(ATerm* t) { ATprotect(t); }
  static void unprotect(ATerm* t) { ATunprotect(t); }
  static void mark(ATerm t) { ATmarkTerm(t); }
  static ATerm term(ATerm t) { return t; }
  static ATerm* ptr(ATerm& t) { return &t; }
};

template <>
struct aterm_traits<ATermList>
{
  typedef ATermList aterm_type;
  static void protect(ATermList* t) { aterm_traits<ATerm>::protect(reinterpret_cast<ATerm*>(t)); }
  static void unprotect(ATermList* t) { aterm_traits<ATerm>::unprotect(reinterpret_cast<ATerm*>(t)); }
  static void mark(ATermList t) { aterm_traits<ATerm>::mark(reinterpret_cast<ATerm>(t)); }
  static ATerm term(ATermList t) { return reinterpret_cast<ATerm>(t); }
  static ATerm* ptr(ATermList& t) { return reinterpret_cast<ATerm*>(&t); }
};

template <>
struct aterm_traits<ATermAppl>
{
  typedef ATermAppl aterm_type;
  static void protect(ATermAppl* t) { aterm_traits<ATerm>::protect(reinterpret_cast<ATerm*>(t)); }
  static void unprotect(ATermAppl* t) { aterm_traits<ATerm>::unprotect(reinterpret_cast<ATerm*>(t)); }
  static void mark(ATermAppl t) { aterm_traits<ATerm>::mark(reinterpret_cast<ATerm>(t)); }
  static ATerm term(ATermAppl t) { return reinterpret_cast<ATerm>(t); }
  static ATerm* ptr(ATermAppl& t) { return reinterpret_cast<ATerm*>(&t); }
};

template <>
struct aterm_traits<ATermBlob>
{
  typedef ATermBlob aterm_type;
  static void protect(ATermBlob* t) { aterm_traits<ATerm>::protect(reinterpret_cast<ATerm*>(t)); }
  static void unprotect(ATermBlob* t) { aterm_traits<ATerm>::unprotect(reinterpret_cast<ATerm*>(t)); }
  static void mark(ATermBlob t) { aterm_traits<ATerm>::mark(reinterpret_cast<ATerm>(t)); }
  static ATerm term(ATermBlob t) { return reinterpret_cast<ATerm>(t); }
  static ATerm* ptr(ATermBlob& t) { return reinterpret_cast<ATerm*>(&t); }
};

template <>
struct aterm_traits<ATermReal>
{
  typedef ATermReal aterm_type;
  static void protect(ATermReal* t) { aterm_traits<ATerm>::protect(reinterpret_cast<ATerm*>(t)); }
  static void unprotect(ATermReal* t) { aterm_traits<ATerm>::unprotect(reinterpret_cast<ATerm*>(t)); }
  static void mark(ATermReal t) { aterm_traits<ATerm>::mark(reinterpret_cast<ATerm>(t)); }
  static ATerm term(ATermReal t) { return reinterpret_cast<ATerm>(t); }
  static ATerm* ptr(ATermReal& t) { return reinterpret_cast<ATerm*>(&t); }
};

template <>
struct aterm_traits<ATermInt>
{
  typedef ATermInt aterm_type;
  static void protect(ATermInt* t) { aterm_traits<ATerm>::protect(reinterpret_cast<ATerm*>(t)); }
  static void unprotect(ATermInt* t) { aterm_traits<ATerm>::unprotect(reinterpret_cast<ATerm*>(t)); }
  static void mark(ATermInt t) { aterm_traits<ATerm>::mark(reinterpret_cast<ATerm>(t)); }
  static ATerm term(ATermInt t) { return reinterpret_cast<ATerm>(t); }
  static ATerm* ptr(ATermInt& t) { return reinterpret_cast<ATerm*>(&t); }
};


}
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 2


namespace atermpp
{

  class aterm_base
  {
    template <typename T>
    friend struct aterm_traits;

    template <typename T>
    friend struct aterm_appl_traits;

    protected:

      ATerm m_term;



      const ATerm& term() const
      { return m_term; }



      ATerm& term()
      { return m_term; }

    public:

      aterm_base()
        : m_term(0)
      {}



      aterm_base(ATerm term)
        : m_term(term)
      { (((m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)) ? static_cast<void> (0) : __assert_fail ("(m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h", 57, __PRETTY_FUNCTION__));
      }



      aterm_base(ATermList term)
        : m_term(reinterpret_cast<ATerm>(term))
      { (((m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)) ? static_cast<void> (0) : __assert_fail ("(m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h", 64, __PRETTY_FUNCTION__));
      }



      aterm_base(ATermInt term)
        : m_term(reinterpret_cast<ATerm>(term))
      { (((m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)) ? static_cast<void> (0) : __assert_fail ("(m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h", 71, __PRETTY_FUNCTION__));
      }



      aterm_base(ATermReal term)
        : m_term(reinterpret_cast<ATerm>(term))
      { (((m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)) ? static_cast<void> (0) : __assert_fail ("(m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h", 78, __PRETTY_FUNCTION__));
      }



      aterm_base(ATermBlob term)
        : m_term(reinterpret_cast<ATerm>(term))
      { (((m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)) ? static_cast<void> (0) : __assert_fail ("(m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h", 85, __PRETTY_FUNCTION__));
      }



      aterm_base(ATermAppl term)
        : m_term(reinterpret_cast<ATerm>(term))
      { (((m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)) ? static_cast<void> (0) : __assert_fail ("(m_term==__null) || (((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4))!=0L)", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h", 92, __PRETTY_FUNCTION__));
      }



      aterm_base(const std::string& s)
        : m_term(ATmake(const_cast<char*>(s.c_str())))
      {}



      void protect()
      {
        ATprotect(&m_term);
      }




      void unprotect()
      {
        ATunprotect(&m_term);
      }


      void mark()
      {
        ATmarkTerm(m_term);
      }





      int type() const
      { return ((unsigned int)((((m_term)->header) & (((1 << 3)-1) << 4)) >> 4)); }



      std::string to_string() const
      { return std::string(ATwriteToString(m_term)); }
  };


  template <>
  struct aterm_traits<aterm_base>
  {
    typedef ATerm aterm_type;
    static void protect(aterm_base t) { t.protect(); }
    static void unprotect(aterm_base t) { t.unprotect(); }
    static void mark(aterm_base t) { t.mark(); }
    static ATerm term(aterm_base t) { return t.term(); }
    static ATerm* ptr(aterm_base& t) { return &t.term(); }
  };






  inline
  bool operator!(const aterm_base& x)
  {
    return ((ATbool)((ATerm)(aterm_traits<aterm_base>::term(x)) == (ATerm)(ATfalse)));
  }





  inline
  std::ostream& operator<<(std::ostream& out, const aterm_base& t)
  {
    return out << t.to_string();
  }




  class aterm: public aterm_base
  {
    public:

      aterm() {}



      aterm(aterm_base term)
        : aterm_base(term)
      { }



      aterm(ATerm term)
        : aterm_base(term)
      { }



      aterm(ATermList term)
        : aterm_base(term)
      { }



      aterm(ATermInt term)
        : aterm_base(term)
      { }



      aterm(ATermReal term)
        : aterm_base(term)
      { }



      aterm(ATermBlob term)
        : aterm_base(term)
      { }



      aterm(ATermAppl term)
        : aterm_base(term)
      { }



      aterm(const std::string& s)
        : aterm_base(s)
      { }



      operator ATerm() const
      { return m_term; }
  };


  template <>
  struct aterm_traits<aterm>
  {
    typedef ATerm aterm_type;
    static void protect(aterm t) { t.protect(); }
    static void unprotect(aterm t) { t.unprotect(); }
    static void mark(aterm t) { t.mark(); }
    static ATerm term(aterm t) { return t.term(); }
    static ATerm* ptr(aterm& t) { return &t.term(); }
  };






  inline
  aterm read_from_string(const std::string& s)
  {
    return ATreadFromString(s.c_str());
  }






  inline
  aterm read_from_binary_string(const std::string& s, unsigned int size)
  {
    return ATreadFromBinaryString(reinterpret_cast<const unsigned char *>(s.c_str()), size);
  }






  inline
  aterm read_from_shared_string(const std::string& s, unsigned int size)
  {
    return ATreadFromSharedString(s.c_str(), size);
  }






  inline
  aterm read_from_named_file(const std::string& name)
  {
    return ATreadFromNamedFile(name.c_str());
  }







  inline
  bool write_to_named_text_file(aterm t, const std::string& filename)
  {
    return ATwriteToNamedTextFile(t, filename.c_str()) == ATtrue;
  }





  inline
  bool write_to_named_binary_file(aterm t, const std::string& filename)
  {
    return ATwriteToNamedBinaryFile(t, filename.c_str()) == ATtrue;
  }





  inline
  bool write_to_named_saf_file(aterm t, const std::string& filename)
  {
    return ATwriteToNamedSAFFile(t, filename.c_str()) == ATtrue;
  }
# 326 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h"
  inline
  aterm set_annotation(aterm t, aterm label, aterm annotation)
  {
    return ATsetAnnotation(t, label, annotation);
  }
# 339 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h"
  inline
  aterm get_annotation(aterm t, aterm label)
  {
    return ATgetAnnotation(t, label);
  }







  inline
  aterm remove_annotation(aterm t, aterm label)
  {
    return ATremoveAnnotation(t, label);
  }





  inline
  bool operator==(const aterm& x, const aterm& y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(y))) == ATtrue;
  }





  inline
  bool operator==(const aterm& x, ATerm y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(y))) == ATtrue;
  }





  inline
  bool operator==(const ATerm& x, aterm y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(y))) == ATtrue;
  }





  inline
  bool operator!=(const aterm& x, const aterm& y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(y))) == ATfalse;
  }





  inline
  bool operator!=(const aterm& x, ATerm y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(y))) == ATfalse;
  }





  inline
  bool operator!=(const ATerm& x, aterm y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(y))) == ATfalse;
  }

}
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h" 2

namespace mcrl2 {
  namespace core {


typedef enum { ppDefault, ppDebug, ppInternal, ppInternalDebug} t_pp_format;






inline
std::string pp_format_to_string(const t_pp_format pp_format)
{
  switch(pp_format)
  {
    case ppDefault:
      return "default";
    case ppDebug:
      return "debug";
    case ppInternal:
      return "internal";
    case ppInternalDebug:
      return "internal_debug";
    default:
      throw mcrl2::runtime_error("Unknown pretty print format");
  }
}







int gsprintf(const char *format, ...);







int gsfprintf(FILE *stream, const char *format, ...);







int gsvfprintf(FILE *stream, const char *format, va_list args);
# 86 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h"
void PrintPart_C(FILE *out_stream, const ATerm part, t_pp_format pp_format = ppDefault);
# 97 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h"
void PrintPart_CXX(std::ostream &out_stream, const ATerm part,
  t_pp_format pp_format = ppDefault);
# 107 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h"
std::string PrintPart_CXX(const ATerm part, t_pp_format pp_format = ppDefault);
# 116 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/print.h"
template <typename Term>
std::string pp(Term part, t_pp_format pp_format = ppDefault)
{
  return PrintPart_CXX(atermpp::aterm_traits<Term>::term(part), pp_format);
}

  }
}
# 14 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp" 2


# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 1
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
# 1 "/usr/include/assert.h" 1 3 4
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/aterm2.h" 1
# 30 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/messaging.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/messaging.h"
# 1 "/usr/include/c++/4.1.3/cstdarg" 1 3
# 48 "/usr/include/c++/4.1.3/cstdarg" 3
       
# 49 "/usr/include/c++/4.1.3/cstdarg" 3
# 57 "/usr/include/c++/4.1.3/cstdarg" 3
namespace std
{
  using ::va_list;
}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/messaging.h" 2
# 1 "/usr/include/c++/4.1.3/cassert" 1 3
# 47 "/usr/include/c++/4.1.3/cassert" 3
       
# 48 "/usr/include/c++/4.1.3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 49 "/usr/include/c++/4.1.3/cassert" 2 3
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/messaging.h" 2
# 1 "/usr/include/boost/current_function.hpp" 1 3 4
# 22 "/usr/include/boost/current_function.hpp" 3 4
namespace boost
{

namespace detail
{

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

}

}
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/messaging.h" 2

namespace mcrl2 {

  namespace core {






      void gsSetQuietMsg();



      void gsSetNormalMsg();



      void gsSetVerboseMsg();



      void gsSetDebugMsg();



      extern bool gsQuiet;



      extern bool gsWarning;



      extern bool gsVerbose;



      extern bool gsDebug;


      enum messageType {gs_notice, gs_warning, gs_error};


      void gsMessage(const char *Format, ...);

      void gsErrorMsg(const char *Format, ...);

      void gsVerboseMsg(const char *Format, ...);

      void gsWarningMsg(const char *Format, ...);

      void gsDebugMsg(const char *Format, ...);

      void gsDebugMsgFunc(const char *FuncName, const char *Format, ...);





      void gsSetCustomMessageHandler(void (*)(messageType, const char*));
  }
}
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h" 1
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
# 1 "/usr/include/c++/4.1.3/cassert" 1 3
# 47 "/usr/include/c++/4.1.3/cassert" 3
       
# 48 "/usr/include/c++/4.1.3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 49 "/usr/include/c++/4.1.3/cassert" 2 3
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h" 2


namespace mcrl2 {
  namespace core {
# 84 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
inline ATermList ATinsertUnique(ATermList list, ATerm el)
{
  if (ATindexOf(list, el, 0) == -1) return ATinsert(list, el);
  return list;
}






inline bool ATisApplOrNull(ATerm t)
{
  return (t == 0) || ((unsigned int)((((t)->header) & (((1 << 3)-1) << 4)) >> 4)) == 1L;
}






inline bool ATisListOrNull(ATerm t)
{
  return (t == 0) || ((unsigned int)((((t)->header) & (((1 << 3)-1) << 4)) >> 4)) == 4L;
}




inline ATermAppl ATAelementAt(ATermList List, int Index) {
  ATerm Result = ATelementAt(List, Index);
  ((ATisApplOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisApplOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 115, __PRETTY_FUNCTION__));
  return (ATermAppl) Result;
}




inline ATermList ATLelementAt(ATermList List, int Index)
{
  ATerm Result = ATelementAt(List, Index);
  ((ATisListOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisListOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 125, __PRETTY_FUNCTION__));
  return (ATermList) Result;
}




inline ATermAppl ATAgetArgument(ATermAppl Appl, int Nr)
{
  ATerm Result = (((ATermAppl)Appl)->aterm.arg[Nr]);
  ((ATisApplOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisApplOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 135, __PRETTY_FUNCTION__));
  return (ATermAppl) Result;
}




inline ATermList ATLgetArgument(ATermAppl Appl, int Nr)
{
  ATerm Result = (((ATermAppl)Appl)->aterm.arg[Nr]);
  ((ATisListOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisListOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 145, __PRETTY_FUNCTION__));
  return (ATermList) Result;
}




inline ATermAppl ATAgetFirst(ATermList List)
{
  ATerm Result = (((ATermList)List)->aterm.head);
  ((ATisApplOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisApplOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 155, __PRETTY_FUNCTION__));
  return (ATermAppl) Result;
}




inline ATermList ATLgetFirst(ATermList List)
{
  ATerm Result = (((ATermList)List)->aterm.head);
  ((ATisListOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisListOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 165, __PRETTY_FUNCTION__));
  return (ATermList) Result;
}




inline ATermAppl ATAtableGet(ATermTable Table, ATerm Key)
{
  ATerm Result = ATtableGet(Table, Key);
  ((ATisApplOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisApplOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 175, __PRETTY_FUNCTION__));
  return (ATermAppl) Result;
}




inline ATermList ATLtableGet(ATermTable Table, ATerm Key)
{
  ATerm Result = ATtableGet(Table, Key);
  ((ATisListOrNull(Result)) ? static_cast<void> (0) : __assert_fail ("ATisListOrNull(Result)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h", 185, __PRETTY_FUNCTION__));
  return (ATermList) Result;
}
# 260 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
ATermAppl gsMakeSubst(ATerm old_value, ATerm new_value);
# 271 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
inline ATermAppl gsMakeSubst_Appl(ATermAppl old_value, ATermAppl new_value) {
  return gsMakeSubst((ATerm) old_value, (ATerm) new_value);
}
# 284 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
inline ATermAppl gsMakeSubst_List(ATermList old_value, ATermList new_value) {
  return gsMakeSubst((ATerm) old_value, (ATerm) new_value);
}
# 301 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
ATerm gsSubstValues(ATermList substs, ATerm term, bool recursive);
# 317 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
inline ATermAppl gsSubstValues_Appl(ATermList substs, ATermAppl appl, bool recursive) {
  return (ATermAppl) gsSubstValues(substs, (ATerm) appl, recursive);
}
# 335 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
inline ATermList gsSubstValues_List(ATermList substs, ATermList list, bool recursive) {
  return (ATermList) gsSubstValues(substs, (ATerm) list, recursive);
}
# 349 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
ATerm gsSubstValuesTable(ATermTable substs, ATerm term, bool recursive);
# 362 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
ATermList gsAddSubstToSubsts(ATermAppl subst, ATermList substs);
# 376 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
bool gsOccurs(ATerm elt, ATerm term);







int gsCount(ATerm elt, ATerm term);
# 393 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/aterm_ext.h"
int gsCountAFun(AFun fun, ATerm term);
  }
}
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h" 1
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h"
# 1 "/usr/include/assert.h" 1 3 4
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h" 2


namespace mcrl2 {
  namespace core {
    namespace detail {





inline
AFun initAFunActAnd(AFun& f)
{
  f = ATmakeAFun("ActAnd", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActAnd()
{
  static AFun AFunActAnd = initAFunActAnd(AFunActAnd);
  return AFunActAnd;
}

inline
bool gsIsActAnd(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActAnd();
}


inline
AFun initAFunActAt(AFun& f)
{
  f = ATmakeAFun("ActAt", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActAt()
{
  static AFun AFunActAt = initAFunActAt(AFunActAt);
  return AFunActAt;
}

inline
bool gsIsActAt(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActAt();
}


inline
AFun initAFunActExists(AFun& f)
{
  f = ATmakeAFun("ActExists", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActExists()
{
  static AFun AFunActExists = initAFunActExists(AFunActExists);
  return AFunActExists;
}

inline
bool gsIsActExists(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActExists();
}


inline
AFun initAFunActFalse(AFun& f)
{
  f = ATmakeAFun("ActFalse", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActFalse()
{
  static AFun AFunActFalse = initAFunActFalse(AFunActFalse);
  return AFunActFalse;
}

inline
bool gsIsActFalse(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActFalse();
}


inline
AFun initAFunActForall(AFun& f)
{
  f = ATmakeAFun("ActForall", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActForall()
{
  static AFun AFunActForall = initAFunActForall(AFunActForall);
  return AFunActForall;
}

inline
bool gsIsActForall(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActForall();
}


inline
AFun initAFunActId(AFun& f)
{
  f = ATmakeAFun("ActId", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActId()
{
  static AFun AFunActId = initAFunActId(AFunActId);
  return AFunActId;
}

inline
bool gsIsActId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActId();
}


inline
AFun initAFunActImp(AFun& f)
{
  f = ATmakeAFun("ActImp", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActImp()
{
  static AFun AFunActImp = initAFunActImp(AFunActImp);
  return AFunActImp;
}

inline
bool gsIsActImp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActImp();
}


inline
AFun initAFunActNot(AFun& f)
{
  f = ATmakeAFun("ActNot", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActNot()
{
  static AFun AFunActNot = initAFunActNot(AFunActNot);
  return AFunActNot;
}

inline
bool gsIsActNot(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActNot();
}


inline
AFun initAFunActOr(AFun& f)
{
  f = ATmakeAFun("ActOr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActOr()
{
  static AFun AFunActOr = initAFunActOr(AFunActOr);
  return AFunActOr;
}

inline
bool gsIsActOr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActOr();
}


inline
AFun initAFunActSpec(AFun& f)
{
  f = ATmakeAFun("ActSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActSpec()
{
  static AFun AFunActSpec = initAFunActSpec(AFunActSpec);
  return AFunActSpec;
}

inline
bool gsIsActSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActSpec();
}


inline
AFun initAFunActTrue(AFun& f)
{
  f = ATmakeAFun("ActTrue", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActTrue()
{
  static AFun AFunActTrue = initAFunActTrue(AFunActTrue);
  return AFunActTrue;
}

inline
bool gsIsActTrue(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActTrue();
}


inline
AFun initAFunAction(AFun& f)
{
  f = ATmakeAFun("Action", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunAction()
{
  static AFun AFunAction = initAFunAction(AFunAction);
  return AFunAction;
}

inline
bool gsIsAction(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunAction();
}


inline
AFun initAFunActionRenameRule(AFun& f)
{
  f = ATmakeAFun("ActionRenameRule", 4, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActionRenameRule()
{
  static AFun AFunActionRenameRule = initAFunActionRenameRule(AFunActionRenameRule);
  return AFunActionRenameRule;
}

inline
bool gsIsActionRenameRule(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActionRenameRule();
}


inline
AFun initAFunActionRenameRules(AFun& f)
{
  f = ATmakeAFun("ActionRenameRules", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActionRenameRules()
{
  static AFun AFunActionRenameRules = initAFunActionRenameRules(AFunActionRenameRules);
  return AFunActionRenameRules;
}

inline
bool gsIsActionRenameRules(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActionRenameRules();
}


inline
AFun initAFunActionRenameSpec(AFun& f)
{
  f = ATmakeAFun("ActionRenameSpec", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunActionRenameSpec()
{
  static AFun AFunActionRenameSpec = initAFunActionRenameSpec(AFunActionRenameSpec);
  return AFunActionRenameSpec;
}

inline
bool gsIsActionRenameSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunActionRenameSpec();
}


inline
AFun initAFunAllow(AFun& f)
{
  f = ATmakeAFun("Allow", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunAllow()
{
  static AFun AFunAllow = initAFunAllow(AFunAllow);
  return AFunAllow;
}

inline
bool gsIsAllow(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunAllow();
}


inline
AFun initAFunAtTime(AFun& f)
{
  f = ATmakeAFun("AtTime", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunAtTime()
{
  static AFun AFunAtTime = initAFunAtTime(AFunAtTime);
  return AFunAtTime;
}

inline
bool gsIsAtTime(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunAtTime();
}


inline
AFun initAFunBES(AFun& f)
{
  f = ATmakeAFun("BES", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBES()
{
  static AFun AFunBES = initAFunBES(AFunBES);
  return AFunBES;
}

inline
bool gsIsBES(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBES();
}


inline
AFun initAFunBInit(AFun& f)
{
  f = ATmakeAFun("BInit", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBInit()
{
  static AFun AFunBInit = initAFunBInit(AFunBInit);
  return AFunBInit;
}

inline
bool gsIsBInit(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBInit();
}


inline
AFun initAFunBagComp(AFun& f)
{
  f = ATmakeAFun("BagComp", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBagComp()
{
  static AFun AFunBagComp = initAFunBagComp(AFunBagComp);
  return AFunBagComp;
}

inline
bool gsIsBagComp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBagComp();
}


inline
AFun initAFunBinder(AFun& f)
{
  f = ATmakeAFun("Binder", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBinder()
{
  static AFun AFunBinder = initAFunBinder(AFunBinder);
  return AFunBinder;
}

inline
bool gsIsBinder(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBinder();
}


inline
AFun initAFunBlock(AFun& f)
{
  f = ATmakeAFun("Block", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBlock()
{
  static AFun AFunBlock = initAFunBlock(AFunBlock);
  return AFunBlock;
}

inline
bool gsIsBlock(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBlock();
}


inline
AFun initAFunBooleanAnd(AFun& f)
{
  f = ATmakeAFun("BooleanAnd", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanAnd()
{
  static AFun AFunBooleanAnd = initAFunBooleanAnd(AFunBooleanAnd);
  return AFunBooleanAnd;
}

inline
bool gsIsBooleanAnd(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanAnd();
}


inline
AFun initAFunBooleanEquation(AFun& f)
{
  f = ATmakeAFun("BooleanEquation", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanEquation()
{
  static AFun AFunBooleanEquation = initAFunBooleanEquation(AFunBooleanEquation);
  return AFunBooleanEquation;
}

inline
bool gsIsBooleanEquation(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanEquation();
}


inline
AFun initAFunBooleanFalse(AFun& f)
{
  f = ATmakeAFun("BooleanFalse", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanFalse()
{
  static AFun AFunBooleanFalse = initAFunBooleanFalse(AFunBooleanFalse);
  return AFunBooleanFalse;
}

inline
bool gsIsBooleanFalse(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanFalse();
}


inline
AFun initAFunBooleanImp(AFun& f)
{
  f = ATmakeAFun("BooleanImp", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanImp()
{
  static AFun AFunBooleanImp = initAFunBooleanImp(AFunBooleanImp);
  return AFunBooleanImp;
}

inline
bool gsIsBooleanImp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanImp();
}


inline
AFun initAFunBooleanNot(AFun& f)
{
  f = ATmakeAFun("BooleanNot", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanNot()
{
  static AFun AFunBooleanNot = initAFunBooleanNot(AFunBooleanNot);
  return AFunBooleanNot;
}

inline
bool gsIsBooleanNot(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanNot();
}


inline
AFun initAFunBooleanOr(AFun& f)
{
  f = ATmakeAFun("BooleanOr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanOr()
{
  static AFun AFunBooleanOr = initAFunBooleanOr(AFunBooleanOr);
  return AFunBooleanOr;
}

inline
bool gsIsBooleanOr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanOr();
}


inline
AFun initAFunBooleanTrue(AFun& f)
{
  f = ATmakeAFun("BooleanTrue", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanTrue()
{
  static AFun AFunBooleanTrue = initAFunBooleanTrue(AFunBooleanTrue);
  return AFunBooleanTrue;
}

inline
bool gsIsBooleanTrue(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanTrue();
}


inline
AFun initAFunBooleanVariable(AFun& f)
{
  f = ATmakeAFun("BooleanVariable", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunBooleanVariable()
{
  static AFun AFunBooleanVariable = initAFunBooleanVariable(AFunBooleanVariable);
  return AFunBooleanVariable;
}

inline
bool gsIsBooleanVariable(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunBooleanVariable();
}


inline
AFun initAFunChoice(AFun& f)
{
  f = ATmakeAFun("Choice", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunChoice()
{
  static AFun AFunChoice = initAFunChoice(AFunChoice);
  return AFunChoice;
}

inline
bool gsIsChoice(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunChoice();
}


inline
AFun initAFunComm(AFun& f)
{
  f = ATmakeAFun("Comm", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunComm()
{
  static AFun AFunComm = initAFunComm(AFunComm);
  return AFunComm;
}

inline
bool gsIsComm(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunComm();
}


inline
AFun initAFunCommExpr(AFun& f)
{
  f = ATmakeAFun("CommExpr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunCommExpr()
{
  static AFun AFunCommExpr = initAFunCommExpr(AFunCommExpr);
  return AFunCommExpr;
}

inline
bool gsIsCommExpr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunCommExpr();
}


inline
AFun initAFunConsSpec(AFun& f)
{
  f = ATmakeAFun("ConsSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunConsSpec()
{
  static AFun AFunConsSpec = initAFunConsSpec(AFunConsSpec);
  return AFunConsSpec;
}

inline
bool gsIsConsSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunConsSpec();
}


inline
AFun initAFunDataAppl(AFun& f)
{
  f = ATmakeAFun("DataAppl", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDataAppl()
{
  static AFun AFunDataAppl = initAFunDataAppl(AFunDataAppl);
  return AFunDataAppl;
}

inline
bool gsIsDataAppl(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDataAppl();
}


inline
AFun initAFunDataEqn(AFun& f)
{
  f = ATmakeAFun("DataEqn", 4, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDataEqn()
{
  static AFun AFunDataEqn = initAFunDataEqn(AFunDataEqn);
  return AFunDataEqn;
}

inline
bool gsIsDataEqn(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDataEqn();
}


inline
AFun initAFunDataEqnSpec(AFun& f)
{
  f = ATmakeAFun("DataEqnSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDataEqnSpec()
{
  static AFun AFunDataEqnSpec = initAFunDataEqnSpec(AFunDataEqnSpec);
  return AFunDataEqnSpec;
}

inline
bool gsIsDataEqnSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDataEqnSpec();
}


inline
AFun initAFunDataSpec(AFun& f)
{
  f = ATmakeAFun("DataSpec", 4, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDataSpec()
{
  static AFun AFunDataSpec = initAFunDataSpec(AFunDataSpec);
  return AFunDataSpec;
}

inline
bool gsIsDataSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDataSpec();
}


inline
AFun initAFunDataVarId(AFun& f)
{
  f = ATmakeAFun("DataVarId", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDataVarId()
{
  static AFun AFunDataVarId = initAFunDataVarId(AFunDataVarId);
  return AFunDataVarId;
}

inline
bool gsIsDataVarId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDataVarId();
}


inline
AFun initAFunDataVarIdInit(AFun& f)
{
  f = ATmakeAFun("DataVarIdInit", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDataVarIdInit()
{
  static AFun AFunDataVarIdInit = initAFunDataVarIdInit(AFunDataVarIdInit);
  return AFunDataVarIdInit;
}

inline
bool gsIsDataVarIdInit(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDataVarIdInit();
}


inline
AFun initAFunDelta(AFun& f)
{
  f = ATmakeAFun("Delta", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunDelta()
{
  static AFun AFunDelta = initAFunDelta(AFunDelta);
  return AFunDelta;
}

inline
bool gsIsDelta(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunDelta();
}


inline
AFun initAFunExists(AFun& f)
{
  f = ATmakeAFun("Exists", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunExists()
{
  static AFun AFunExists = initAFunExists(AFunExists);
  return AFunExists;
}

inline
bool gsIsExists(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunExists();
}


inline
AFun initAFunForall(AFun& f)
{
  f = ATmakeAFun("Forall", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunForall()
{
  static AFun AFunForall = initAFunForall(AFunForall);
  return AFunForall;
}

inline
bool gsIsForall(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunForall();
}


inline
AFun initAFunGlobVarSpec(AFun& f)
{
  f = ATmakeAFun("GlobVarSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunGlobVarSpec()
{
  static AFun AFunGlobVarSpec = initAFunGlobVarSpec(AFunGlobVarSpec);
  return AFunGlobVarSpec;
}

inline
bool gsIsGlobVarSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunGlobVarSpec();
}


inline
AFun initAFunHide(AFun& f)
{
  f = ATmakeAFun("Hide", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunHide()
{
  static AFun AFunHide = initAFunHide(AFunHide);
  return AFunHide;
}

inline
bool gsIsHide(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunHide();
}


inline
AFun initAFunId(AFun& f)
{
  f = ATmakeAFun("Id", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunId()
{
  static AFun AFunId = initAFunId(AFunId);
  return AFunId;
}

inline
bool gsIsId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunId();
}


inline
AFun initAFunIdAssignment(AFun& f)
{
  f = ATmakeAFun("IdAssignment", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunIdAssignment()
{
  static AFun AFunIdAssignment = initAFunIdAssignment(AFunIdAssignment);
  return AFunIdAssignment;
}

inline
bool gsIsIdAssignment(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunIdAssignment();
}


inline
AFun initAFunIdInit(AFun& f)
{
  f = ATmakeAFun("IdInit", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunIdInit()
{
  static AFun AFunIdInit = initAFunIdInit(AFunIdInit);
  return AFunIdInit;
}

inline
bool gsIsIdInit(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunIdInit();
}


inline
AFun initAFunIfThen(AFun& f)
{
  f = ATmakeAFun("IfThen", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunIfThen()
{
  static AFun AFunIfThen = initAFunIfThen(AFunIfThen);
  return AFunIfThen;
}

inline
bool gsIsIfThen(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunIfThen();
}


inline
AFun initAFunIfThenElse(AFun& f)
{
  f = ATmakeAFun("IfThenElse", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunIfThenElse()
{
  static AFun AFunIfThenElse = initAFunIfThenElse(AFunIfThenElse);
  return AFunIfThenElse;
}

inline
bool gsIsIfThenElse(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunIfThenElse();
}


inline
AFun initAFunLMerge(AFun& f)
{
  f = ATmakeAFun("LMerge", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunLMerge()
{
  static AFun AFunLMerge = initAFunLMerge(AFunLMerge);
  return AFunLMerge;
}

inline
bool gsIsLMerge(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunLMerge();
}


inline
AFun initAFunLambda(AFun& f)
{
  f = ATmakeAFun("Lambda", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunLambda()
{
  static AFun AFunLambda = initAFunLambda(AFunLambda);
  return AFunLambda;
}

inline
bool gsIsLambda(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunLambda();
}


inline
AFun initAFunLinProcSpec(AFun& f)
{
  f = ATmakeAFun("LinProcSpec", 5, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunLinProcSpec()
{
  static AFun AFunLinProcSpec = initAFunLinProcSpec(AFunLinProcSpec);
  return AFunLinProcSpec;
}

inline
bool gsIsLinProcSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunLinProcSpec();
}


inline
AFun initAFunLinearProcess(AFun& f)
{
  f = ATmakeAFun("LinearProcess", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunLinearProcess()
{
  static AFun AFunLinearProcess = initAFunLinearProcess(AFunLinearProcess);
  return AFunLinearProcess;
}

inline
bool gsIsLinearProcess(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunLinearProcess();
}


inline
AFun initAFunLinearProcessInit(AFun& f)
{
  f = ATmakeAFun("LinearProcessInit", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunLinearProcessInit()
{
  static AFun AFunLinearProcessInit = initAFunLinearProcessInit(AFunLinearProcessInit);
  return AFunLinearProcessInit;
}

inline
bool gsIsLinearProcessInit(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunLinearProcessInit();
}


inline
AFun initAFunLinearProcessSummand(AFun& f)
{
  f = ATmakeAFun("LinearProcessSummand", 5, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunLinearProcessSummand()
{
  static AFun AFunLinearProcessSummand = initAFunLinearProcessSummand(AFunLinearProcessSummand);
  return AFunLinearProcessSummand;
}

inline
bool gsIsLinearProcessSummand(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunLinearProcessSummand();
}


inline
AFun initAFunMapSpec(AFun& f)
{
  f = ATmakeAFun("MapSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunMapSpec()
{
  static AFun AFunMapSpec = initAFunMapSpec(AFunMapSpec);
  return AFunMapSpec;
}

inline
bool gsIsMapSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunMapSpec();
}


inline
AFun initAFunMerge(AFun& f)
{
  f = ATmakeAFun("Merge", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunMerge()
{
  static AFun AFunMerge = initAFunMerge(AFunMerge);
  return AFunMerge;
}

inline
bool gsIsMerge(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunMerge();
}


inline
AFun initAFunMu(AFun& f)
{
  f = ATmakeAFun("Mu", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunMu()
{
  static AFun AFunMu = initAFunMu(AFunMu);
  return AFunMu;
}

inline
bool gsIsMu(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunMu();
}


inline
AFun initAFunMultAct(AFun& f)
{
  f = ATmakeAFun("MultAct", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunMultAct()
{
  static AFun AFunMultAct = initAFunMultAct(AFunMultAct);
  return AFunMultAct;
}

inline
bool gsIsMultAct(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunMultAct();
}


inline
AFun initAFunMultActName(AFun& f)
{
  f = ATmakeAFun("MultActName", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunMultActName()
{
  static AFun AFunMultActName = initAFunMultActName(AFunMultActName);
  return AFunMultActName;
}

inline
bool gsIsMultActName(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunMultActName();
}


inline
AFun initAFunNil(AFun& f)
{
  f = ATmakeAFun("Nil", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunNil()
{
  static AFun AFunNil = initAFunNil(AFunNil);
  return AFunNil;
}

inline
bool gsIsNil(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunNil();
}


inline
AFun initAFunNu(AFun& f)
{
  f = ATmakeAFun("Nu", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunNu()
{
  static AFun AFunNu = initAFunNu(AFunNu);
  return AFunNu;
}

inline
bool gsIsNu(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunNu();
}


inline
AFun initAFunOpId(AFun& f)
{
  f = ATmakeAFun("OpId", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunOpId()
{
  static AFun AFunOpId = initAFunOpId(AFunOpId);
  return AFunOpId;
}

inline
bool gsIsOpId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunOpId();
}


inline
AFun initAFunPBES(AFun& f)
{
  f = ATmakeAFun("PBES", 4, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBES()
{
  static AFun AFunPBES = initAFunPBES(AFunPBES);
  return AFunPBES;
}

inline
bool gsIsPBES(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBES();
}


inline
AFun initAFunPBESAnd(AFun& f)
{
  f = ATmakeAFun("PBESAnd", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESAnd()
{
  static AFun AFunPBESAnd = initAFunPBESAnd(AFunPBESAnd);
  return AFunPBESAnd;
}

inline
bool gsIsPBESAnd(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESAnd();
}


inline
AFun initAFunPBESExists(AFun& f)
{
  f = ATmakeAFun("PBESExists", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESExists()
{
  static AFun AFunPBESExists = initAFunPBESExists(AFunPBESExists);
  return AFunPBESExists;
}

inline
bool gsIsPBESExists(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESExists();
}


inline
AFun initAFunPBESFalse(AFun& f)
{
  f = ATmakeAFun("PBESFalse", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESFalse()
{
  static AFun AFunPBESFalse = initAFunPBESFalse(AFunPBESFalse);
  return AFunPBESFalse;
}

inline
bool gsIsPBESFalse(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESFalse();
}


inline
AFun initAFunPBESForall(AFun& f)
{
  f = ATmakeAFun("PBESForall", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESForall()
{
  static AFun AFunPBESForall = initAFunPBESForall(AFunPBESForall);
  return AFunPBESForall;
}

inline
bool gsIsPBESForall(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESForall();
}


inline
AFun initAFunPBESImp(AFun& f)
{
  f = ATmakeAFun("PBESImp", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESImp()
{
  static AFun AFunPBESImp = initAFunPBESImp(AFunPBESImp);
  return AFunPBESImp;
}

inline
bool gsIsPBESImp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESImp();
}


inline
AFun initAFunPBESNot(AFun& f)
{
  f = ATmakeAFun("PBESNot", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESNot()
{
  static AFun AFunPBESNot = initAFunPBESNot(AFunPBESNot);
  return AFunPBESNot;
}

inline
bool gsIsPBESNot(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESNot();
}


inline
AFun initAFunPBESOr(AFun& f)
{
  f = ATmakeAFun("PBESOr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESOr()
{
  static AFun AFunPBESOr = initAFunPBESOr(AFunPBESOr);
  return AFunPBESOr;
}

inline
bool gsIsPBESOr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESOr();
}


inline
AFun initAFunPBESTrue(AFun& f)
{
  f = ATmakeAFun("PBESTrue", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBESTrue()
{
  static AFun AFunPBESTrue = initAFunPBESTrue(AFunPBESTrue);
  return AFunPBESTrue;
}

inline
bool gsIsPBESTrue(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBESTrue();
}


inline
AFun initAFunPBEqn(AFun& f)
{
  f = ATmakeAFun("PBEqn", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBEqn()
{
  static AFun AFunPBEqn = initAFunPBEqn(AFunPBEqn);
  return AFunPBEqn;
}

inline
bool gsIsPBEqn(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBEqn();
}


inline
AFun initAFunPBEqnSpec(AFun& f)
{
  f = ATmakeAFun("PBEqnSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBEqnSpec()
{
  static AFun AFunPBEqnSpec = initAFunPBEqnSpec(AFunPBEqnSpec);
  return AFunPBEqnSpec;
}

inline
bool gsIsPBEqnSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBEqnSpec();
}


inline
AFun initAFunPBInit(AFun& f)
{
  f = ATmakeAFun("PBInit", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPBInit()
{
  static AFun AFunPBInit = initAFunPBInit(AFunPBInit);
  return AFunPBInit;
}

inline
bool gsIsPBInit(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPBInit();
}


inline
AFun initAFunParamId(AFun& f)
{
  f = ATmakeAFun("ParamId", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunParamId()
{
  static AFun AFunParamId = initAFunParamId(AFunParamId);
  return AFunParamId;
}

inline
bool gsIsParamId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunParamId();
}


inline
AFun initAFunProcEqn(AFun& f)
{
  f = ATmakeAFun("ProcEqn", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcEqn()
{
  static AFun AFunProcEqn = initAFunProcEqn(AFunProcEqn);
  return AFunProcEqn;
}

inline
bool gsIsProcEqn(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcEqn();
}


inline
AFun initAFunProcEqnSpec(AFun& f)
{
  f = ATmakeAFun("ProcEqnSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcEqnSpec()
{
  static AFun AFunProcEqnSpec = initAFunProcEqnSpec(AFunProcEqnSpec);
  return AFunProcEqnSpec;
}

inline
bool gsIsProcEqnSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcEqnSpec();
}


inline
AFun initAFunProcSpec(AFun& f)
{
  f = ATmakeAFun("ProcSpec", 5, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcSpec()
{
  static AFun AFunProcSpec = initAFunProcSpec(AFunProcSpec);
  return AFunProcSpec;
}

inline
bool gsIsProcSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcSpec();
}


inline
AFun initAFunProcVarId(AFun& f)
{
  f = ATmakeAFun("ProcVarId", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcVarId()
{
  static AFun AFunProcVarId = initAFunProcVarId(AFunProcVarId);
  return AFunProcVarId;
}

inline
bool gsIsProcVarId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcVarId();
}


inline
AFun initAFunProcess(AFun& f)
{
  f = ATmakeAFun("Process", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcess()
{
  static AFun AFunProcess = initAFunProcess(AFunProcess);
  return AFunProcess;
}

inline
bool gsIsProcess(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcess();
}


inline
AFun initAFunProcessAssignment(AFun& f)
{
  f = ATmakeAFun("ProcessAssignment", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcessAssignment()
{
  static AFun AFunProcessAssignment = initAFunProcessAssignment(AFunProcessAssignment);
  return AFunProcessAssignment;
}

inline
bool gsIsProcessAssignment(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcessAssignment();
}


inline
AFun initAFunProcessInit(AFun& f)
{
  f = ATmakeAFun("ProcessInit", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunProcessInit()
{
  static AFun AFunProcessInit = initAFunProcessInit(AFunProcessInit);
  return AFunProcessInit;
}

inline
bool gsIsProcessInit(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunProcessInit();
}


inline
AFun initAFunPropVarDecl(AFun& f)
{
  f = ATmakeAFun("PropVarDecl", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPropVarDecl()
{
  static AFun AFunPropVarDecl = initAFunPropVarDecl(AFunPropVarDecl);
  return AFunPropVarDecl;
}

inline
bool gsIsPropVarDecl(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPropVarDecl();
}


inline
AFun initAFunPropVarInst(AFun& f)
{
  f = ATmakeAFun("PropVarInst", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunPropVarInst()
{
  static AFun AFunPropVarInst = initAFunPropVarInst(AFunPropVarInst);
  return AFunPropVarInst;
}

inline
bool gsIsPropVarInst(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunPropVarInst();
}


inline
AFun initAFunRegAlt(AFun& f)
{
  f = ATmakeAFun("RegAlt", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRegAlt()
{
  static AFun AFunRegAlt = initAFunRegAlt(AFunRegAlt);
  return AFunRegAlt;
}

inline
bool gsIsRegAlt(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRegAlt();
}


inline
AFun initAFunRegNil(AFun& f)
{
  f = ATmakeAFun("RegNil", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRegNil()
{
  static AFun AFunRegNil = initAFunRegNil(AFunRegNil);
  return AFunRegNil;
}

inline
bool gsIsRegNil(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRegNil();
}


inline
AFun initAFunRegSeq(AFun& f)
{
  f = ATmakeAFun("RegSeq", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRegSeq()
{
  static AFun AFunRegSeq = initAFunRegSeq(AFunRegSeq);
  return AFunRegSeq;
}

inline
bool gsIsRegSeq(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRegSeq();
}


inline
AFun initAFunRegTrans(AFun& f)
{
  f = ATmakeAFun("RegTrans", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRegTrans()
{
  static AFun AFunRegTrans = initAFunRegTrans(AFunRegTrans);
  return AFunRegTrans;
}

inline
bool gsIsRegTrans(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRegTrans();
}


inline
AFun initAFunRegTransOrNil(AFun& f)
{
  f = ATmakeAFun("RegTransOrNil", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRegTransOrNil()
{
  static AFun AFunRegTransOrNil = initAFunRegTransOrNil(AFunRegTransOrNil);
  return AFunRegTransOrNil;
}

inline
bool gsIsRegTransOrNil(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRegTransOrNil();
}


inline
AFun initAFunRename(AFun& f)
{
  f = ATmakeAFun("Rename", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRename()
{
  static AFun AFunRename = initAFunRename(AFunRename);
  return AFunRename;
}

inline
bool gsIsRename(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRename();
}


inline
AFun initAFunRenameExpr(AFun& f)
{
  f = ATmakeAFun("RenameExpr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunRenameExpr()
{
  static AFun AFunRenameExpr = initAFunRenameExpr(AFunRenameExpr);
  return AFunRenameExpr;
}

inline
bool gsIsRenameExpr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunRenameExpr();
}


inline
AFun initAFunSeq(AFun& f)
{
  f = ATmakeAFun("Seq", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSeq()
{
  static AFun AFunSeq = initAFunSeq(AFunSeq);
  return AFunSeq;
}

inline
bool gsIsSeq(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSeq();
}


inline
AFun initAFunSetBagComp(AFun& f)
{
  f = ATmakeAFun("SetBagComp", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSetBagComp()
{
  static AFun AFunSetBagComp = initAFunSetBagComp(AFunSetBagComp);
  return AFunSetBagComp;
}

inline
bool gsIsSetBagComp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSetBagComp();
}


inline
AFun initAFunSetComp(AFun& f)
{
  f = ATmakeAFun("SetComp", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSetComp()
{
  static AFun AFunSetComp = initAFunSetComp(AFunSetComp);
  return AFunSetComp;
}

inline
bool gsIsSetComp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSetComp();
}


inline
AFun initAFunSortArrow(AFun& f)
{
  f = ATmakeAFun("SortArrow", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortArrow()
{
  static AFun AFunSortArrow = initAFunSortArrow(AFunSortArrow);
  return AFunSortArrow;
}

inline
bool gsIsSortArrow(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortArrow();
}


inline
AFun initAFunSortBag(AFun& f)
{
  f = ATmakeAFun("SortBag", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortBag()
{
  static AFun AFunSortBag = initAFunSortBag(AFunSortBag);
  return AFunSortBag;
}

inline
bool gsIsSortBag(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortBag();
}


inline
AFun initAFunSortCons(AFun& f)
{
  f = ATmakeAFun("SortCons", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortCons()
{
  static AFun AFunSortCons = initAFunSortCons(AFunSortCons);
  return AFunSortCons;
}

inline
bool gsIsSortCons(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortCons();
}


inline
AFun initAFunSortFBag(AFun& f)
{
  f = ATmakeAFun("SortFBag", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortFBag()
{
  static AFun AFunSortFBag = initAFunSortFBag(AFunSortFBag);
  return AFunSortFBag;
}

inline
bool gsIsSortFBag(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortFBag();
}


inline
AFun initAFunSortFSet(AFun& f)
{
  f = ATmakeAFun("SortFSet", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortFSet()
{
  static AFun AFunSortFSet = initAFunSortFSet(AFunSortFSet);
  return AFunSortFSet;
}

inline
bool gsIsSortFSet(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortFSet();
}


inline
AFun initAFunSortId(AFun& f)
{
  f = ATmakeAFun("SortId", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortId()
{
  static AFun AFunSortId = initAFunSortId(AFunSortId);
  return AFunSortId;
}

inline
bool gsIsSortId(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortId();
}


inline
AFun initAFunSortList(AFun& f)
{
  f = ATmakeAFun("SortList", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortList()
{
  static AFun AFunSortList = initAFunSortList(AFunSortList);
  return AFunSortList;
}

inline
bool gsIsSortList(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortList();
}


inline
AFun initAFunSortRef(AFun& f)
{
  f = ATmakeAFun("SortRef", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortRef()
{
  static AFun AFunSortRef = initAFunSortRef(AFunSortRef);
  return AFunSortRef;
}

inline
bool gsIsSortRef(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortRef();
}


inline
AFun initAFunSortSet(AFun& f)
{
  f = ATmakeAFun("SortSet", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortSet()
{
  static AFun AFunSortSet = initAFunSortSet(AFunSortSet);
  return AFunSortSet;
}

inline
bool gsIsSortSet(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortSet();
}


inline
AFun initAFunSortSpec(AFun& f)
{
  f = ATmakeAFun("SortSpec", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortSpec()
{
  static AFun AFunSortSpec = initAFunSortSpec(AFunSortSpec);
  return AFunSortSpec;
}

inline
bool gsIsSortSpec(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortSpec();
}


inline
AFun initAFunSortStruct(AFun& f)
{
  f = ATmakeAFun("SortStruct", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortStruct()
{
  static AFun AFunSortStruct = initAFunSortStruct(AFunSortStruct);
  return AFunSortStruct;
}

inline
bool gsIsSortStruct(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortStruct();
}


inline
AFun initAFunSortUnknown(AFun& f)
{
  f = ATmakeAFun("SortUnknown", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortUnknown()
{
  static AFun AFunSortUnknown = initAFunSortUnknown(AFunSortUnknown);
  return AFunSortUnknown;
}

inline
bool gsIsSortUnknown(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortUnknown();
}


inline
AFun initAFunSortsPossible(AFun& f)
{
  f = ATmakeAFun("SortsPossible", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSortsPossible()
{
  static AFun AFunSortsPossible = initAFunSortsPossible(AFunSortsPossible);
  return AFunSortsPossible;
}

inline
bool gsIsSortsPossible(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSortsPossible();
}


inline
AFun initAFunStateAnd(AFun& f)
{
  f = ATmakeAFun("StateAnd", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateAnd()
{
  static AFun AFunStateAnd = initAFunStateAnd(AFunStateAnd);
  return AFunStateAnd;
}

inline
bool gsIsStateAnd(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateAnd();
}


inline
AFun initAFunStateDelay(AFun& f)
{
  f = ATmakeAFun("StateDelay", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateDelay()
{
  static AFun AFunStateDelay = initAFunStateDelay(AFunStateDelay);
  return AFunStateDelay;
}

inline
bool gsIsStateDelay(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateDelay();
}


inline
AFun initAFunStateDelayTimed(AFun& f)
{
  f = ATmakeAFun("StateDelayTimed", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateDelayTimed()
{
  static AFun AFunStateDelayTimed = initAFunStateDelayTimed(AFunStateDelayTimed);
  return AFunStateDelayTimed;
}

inline
bool gsIsStateDelayTimed(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateDelayTimed();
}


inline
AFun initAFunStateExists(AFun& f)
{
  f = ATmakeAFun("StateExists", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateExists()
{
  static AFun AFunStateExists = initAFunStateExists(AFunStateExists);
  return AFunStateExists;
}

inline
bool gsIsStateExists(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateExists();
}


inline
AFun initAFunStateFalse(AFun& f)
{
  f = ATmakeAFun("StateFalse", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateFalse()
{
  static AFun AFunStateFalse = initAFunStateFalse(AFunStateFalse);
  return AFunStateFalse;
}

inline
bool gsIsStateFalse(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateFalse();
}


inline
AFun initAFunStateForall(AFun& f)
{
  f = ATmakeAFun("StateForall", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateForall()
{
  static AFun AFunStateForall = initAFunStateForall(AFunStateForall);
  return AFunStateForall;
}

inline
bool gsIsStateForall(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateForall();
}


inline
AFun initAFunStateImp(AFun& f)
{
  f = ATmakeAFun("StateImp", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateImp()
{
  static AFun AFunStateImp = initAFunStateImp(AFunStateImp);
  return AFunStateImp;
}

inline
bool gsIsStateImp(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateImp();
}


inline
AFun initAFunStateMay(AFun& f)
{
  f = ATmakeAFun("StateMay", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateMay()
{
  static AFun AFunStateMay = initAFunStateMay(AFunStateMay);
  return AFunStateMay;
}

inline
bool gsIsStateMay(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateMay();
}


inline
AFun initAFunStateMu(AFun& f)
{
  f = ATmakeAFun("StateMu", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateMu()
{
  static AFun AFunStateMu = initAFunStateMu(AFunStateMu);
  return AFunStateMu;
}

inline
bool gsIsStateMu(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateMu();
}


inline
AFun initAFunStateMust(AFun& f)
{
  f = ATmakeAFun("StateMust", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateMust()
{
  static AFun AFunStateMust = initAFunStateMust(AFunStateMust);
  return AFunStateMust;
}

inline
bool gsIsStateMust(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateMust();
}


inline
AFun initAFunStateNot(AFun& f)
{
  f = ATmakeAFun("StateNot", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateNot()
{
  static AFun AFunStateNot = initAFunStateNot(AFunStateNot);
  return AFunStateNot;
}

inline
bool gsIsStateNot(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateNot();
}


inline
AFun initAFunStateNu(AFun& f)
{
  f = ATmakeAFun("StateNu", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateNu()
{
  static AFun AFunStateNu = initAFunStateNu(AFunStateNu);
  return AFunStateNu;
}

inline
bool gsIsStateNu(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateNu();
}


inline
AFun initAFunStateOr(AFun& f)
{
  f = ATmakeAFun("StateOr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateOr()
{
  static AFun AFunStateOr = initAFunStateOr(AFunStateOr);
  return AFunStateOr;
}

inline
bool gsIsStateOr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateOr();
}


inline
AFun initAFunStateTrue(AFun& f)
{
  f = ATmakeAFun("StateTrue", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateTrue()
{
  static AFun AFunStateTrue = initAFunStateTrue(AFunStateTrue);
  return AFunStateTrue;
}

inline
bool gsIsStateTrue(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateTrue();
}


inline
AFun initAFunStateVar(AFun& f)
{
  f = ATmakeAFun("StateVar", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateVar()
{
  static AFun AFunStateVar = initAFunStateVar(AFunStateVar);
  return AFunStateVar;
}

inline
bool gsIsStateVar(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateVar();
}


inline
AFun initAFunStateYaled(AFun& f)
{
  f = ATmakeAFun("StateYaled", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateYaled()
{
  static AFun AFunStateYaled = initAFunStateYaled(AFunStateYaled);
  return AFunStateYaled;
}

inline
bool gsIsStateYaled(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateYaled();
}


inline
AFun initAFunStateYaledTimed(AFun& f)
{
  f = ATmakeAFun("StateYaledTimed", 1, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStateYaledTimed()
{
  static AFun AFunStateYaledTimed = initAFunStateYaledTimed(AFunStateYaledTimed);
  return AFunStateYaledTimed;
}

inline
bool gsIsStateYaledTimed(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStateYaledTimed();
}


inline
AFun initAFunStructCons(AFun& f)
{
  f = ATmakeAFun("StructCons", 3, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStructCons()
{
  static AFun AFunStructCons = initAFunStructCons(AFunStructCons);
  return AFunStructCons;
}

inline
bool gsIsStructCons(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStructCons();
}


inline
AFun initAFunStructProj(AFun& f)
{
  f = ATmakeAFun("StructProj", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunStructProj()
{
  static AFun AFunStructProj = initAFunStructProj(AFunStructProj);
  return AFunStructProj;
}

inline
bool gsIsStructProj(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunStructProj();
}


inline
AFun initAFunSum(AFun& f)
{
  f = ATmakeAFun("Sum", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSum()
{
  static AFun AFunSum = initAFunSum(AFunSum);
  return AFunSum;
}

inline
bool gsIsSum(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSum();
}


inline
AFun initAFunSync(AFun& f)
{
  f = ATmakeAFun("Sync", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunSync()
{
  static AFun AFunSync = initAFunSync(AFunSync);
  return AFunSync;
}

inline
bool gsIsSync(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunSync();
}


inline
AFun initAFunTau(AFun& f)
{
  f = ATmakeAFun("Tau", 0, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunTau()
{
  static AFun AFunTau = initAFunTau(AFunTau);
  return AFunTau;
}

inline
bool gsIsTau(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunTau();
}


inline
AFun initAFunWhr(AFun& f)
{
  f = ATmakeAFun("Whr", 2, ATfalse);
  ATprotectAFun(f);
  return f;
}

inline
AFun gsAFunWhr()
{
  static AFun AFunWhr = initAFunWhr(AFunWhr);
  return AFunWhr;
}

inline
bool gsIsWhr(ATermAppl Term)
{
  return ((AFun)(((Term)->header) >> 34)) == gsAFunWhr();
}

inline
ATermAppl gsMakeActAnd(ATermAppl ActFrm_0, ATermAppl ActFrm_1)
{
  return ATmakeAppl2(gsAFunActAnd(), (ATerm) ActFrm_0, (ATerm) ActFrm_1);
}

inline
ATermAppl gsMakeActAt(ATermAppl ActFrm_0, ATermAppl DataExpr_1)
{
  return ATmakeAppl2(gsAFunActAt(), (ATerm) ActFrm_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeActExists(ATermList DataVarId_0, ATermAppl ActFrm_1)
{
  return ATmakeAppl2(gsAFunActExists(), (ATerm) DataVarId_0, (ATerm) ActFrm_1);
}

inline
ATermAppl gsMakeActFalse()
{
  return ATmakeAppl0(gsAFunActFalse());
}

inline
ATermAppl gsMakeActForall(ATermList DataVarId_0, ATermAppl ActFrm_1)
{
  return ATmakeAppl2(gsAFunActForall(), (ATerm) DataVarId_0, (ATerm) ActFrm_1);
}

inline
ATermAppl gsMakeActId(ATermAppl String_0, ATermList SortExpr_1)
{
  return ATmakeAppl2(gsAFunActId(), (ATerm) String_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeActImp(ATermAppl ActFrm_0, ATermAppl ActFrm_1)
{
  return ATmakeAppl2(gsAFunActImp(), (ATerm) ActFrm_0, (ATerm) ActFrm_1);
}

inline
ATermAppl gsMakeActNot(ATermAppl ActFrm_0)
{
  return ATmakeAppl1(gsAFunActNot(), (ATerm) ActFrm_0);
}

inline
ATermAppl gsMakeActOr(ATermAppl ActFrm_0, ATermAppl ActFrm_1)
{
  return ATmakeAppl2(gsAFunActOr(), (ATerm) ActFrm_0, (ATerm) ActFrm_1);
}

inline
ATermAppl gsMakeActSpec(ATermList ActId_0)
{
  return ATmakeAppl1(gsAFunActSpec(), (ATerm) ActId_0);
}

inline
ATermAppl gsMakeActTrue()
{
  return ATmakeAppl0(gsAFunActTrue());
}

inline
ATermAppl gsMakeAction(ATermAppl ActId_0, ATermList DataExpr_1)
{
  return ATmakeAppl2(gsAFunAction(), (ATerm) ActId_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeActionRenameRule(ATermList DataVarId_0, ATermAppl DataExpr_1, ATermAppl ParamIdOrAction_2, ATermAppl ActionRenameRuleRHS_3)
{
  return ATmakeAppl4(gsAFunActionRenameRule(), (ATerm) DataVarId_0, (ATerm) DataExpr_1, (ATerm) ParamIdOrAction_2, (ATerm) ActionRenameRuleRHS_3);
}

inline
ATermAppl gsMakeActionRenameRules(ATermList ActionRenameRule_0)
{
  return ATmakeAppl1(gsAFunActionRenameRules(), (ATerm) ActionRenameRule_0);
}

inline
ATermAppl gsMakeActionRenameSpec(ATermAppl DataSpec_0, ATermAppl ActSpec_1, ATermAppl ActionRenameRules_2)
{
  return ATmakeAppl3(gsAFunActionRenameSpec(), (ATerm) DataSpec_0, (ATerm) ActSpec_1, (ATerm) ActionRenameRules_2);
}

inline
ATermAppl gsMakeAllow(ATermList MultActName_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunAllow(), (ATerm) MultActName_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeAtTime(ATermAppl ProcExpr_0, ATermAppl DataExpr_1)
{
  return ATmakeAppl2(gsAFunAtTime(), (ATerm) ProcExpr_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeBES(ATermList BooleanEquation_0, ATermAppl BooleanExpression_1)
{
  return ATmakeAppl2(gsAFunBES(), (ATerm) BooleanEquation_0, (ATerm) BooleanExpression_1);
}

inline
ATermAppl gsMakeBInit(ATermAppl ProcExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunBInit(), (ATerm) ProcExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeBagComp()
{
  return ATmakeAppl0(gsAFunBagComp());
}

inline
ATermAppl gsMakeBinder(ATermAppl BindingOperator_0, ATermList DataVarId_1, ATermAppl DataExpr_2)
{
  return ATmakeAppl3(gsAFunBinder(), (ATerm) BindingOperator_0, (ATerm) DataVarId_1, (ATerm) DataExpr_2);
}

inline
ATermAppl gsMakeBlock(ATermList String_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunBlock(), (ATerm) String_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeBooleanAnd(ATermAppl BooleanExpression_0, ATermAppl BooleanExpression_1)
{
  return ATmakeAppl2(gsAFunBooleanAnd(), (ATerm) BooleanExpression_0, (ATerm) BooleanExpression_1);
}

inline
ATermAppl gsMakeBooleanEquation(ATermAppl FixPoint_0, ATermAppl BooleanVariable_1, ATermAppl BooleanExpression_2)
{
  return ATmakeAppl3(gsAFunBooleanEquation(), (ATerm) FixPoint_0, (ATerm) BooleanVariable_1, (ATerm) BooleanExpression_2);
}

inline
ATermAppl gsMakeBooleanFalse()
{
  return ATmakeAppl0(gsAFunBooleanFalse());
}

inline
ATermAppl gsMakeBooleanImp(ATermAppl BooleanExpression_0, ATermAppl BooleanExpression_1)
{
  return ATmakeAppl2(gsAFunBooleanImp(), (ATerm) BooleanExpression_0, (ATerm) BooleanExpression_1);
}

inline
ATermAppl gsMakeBooleanNot(ATermAppl BooleanExpression_0)
{
  return ATmakeAppl1(gsAFunBooleanNot(), (ATerm) BooleanExpression_0);
}

inline
ATermAppl gsMakeBooleanOr(ATermAppl BooleanExpression_0, ATermAppl BooleanExpression_1)
{
  return ATmakeAppl2(gsAFunBooleanOr(), (ATerm) BooleanExpression_0, (ATerm) BooleanExpression_1);
}

inline
ATermAppl gsMakeBooleanTrue()
{
  return ATmakeAppl0(gsAFunBooleanTrue());
}

inline
ATermAppl gsMakeBooleanVariable(ATermAppl String_0)
{
  return ATmakeAppl1(gsAFunBooleanVariable(), (ATerm) String_0);
}

inline
ATermAppl gsMakeChoice(ATermAppl ProcExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunChoice(), (ATerm) ProcExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeComm(ATermList CommExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunComm(), (ATerm) CommExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeCommExpr(ATermAppl MultActName_0, ATermAppl StringOrNil_1)
{
  return ATmakeAppl2(gsAFunCommExpr(), (ATerm) MultActName_0, (ATerm) StringOrNil_1);
}

inline
ATermAppl gsMakeConsSpec(ATermList OpId_0)
{
  return ATmakeAppl1(gsAFunConsSpec(), (ATerm) OpId_0);
}

inline
ATermAppl gsMakeDataAppl(ATermAppl DataExpr_0, ATermList DataExpr_1)
{
  return ATmakeAppl2(gsAFunDataAppl(), (ATerm) DataExpr_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeDataEqn(ATermList DataVarId_0, ATermAppl DataExpr_1, ATermAppl DataExpr_2, ATermAppl DataExpr_3)
{
  return ATmakeAppl4(gsAFunDataEqn(), (ATerm) DataVarId_0, (ATerm) DataExpr_1, (ATerm) DataExpr_2, (ATerm) DataExpr_3);
}

inline
ATermAppl gsMakeDataEqnSpec(ATermList DataEqn_0)
{
  return ATmakeAppl1(gsAFunDataEqnSpec(), (ATerm) DataEqn_0);
}

inline
ATermAppl gsMakeDataSpec(ATermAppl SortSpec_0, ATermAppl ConsSpec_1, ATermAppl MapSpec_2, ATermAppl DataEqnSpec_3)
{
  return ATmakeAppl4(gsAFunDataSpec(), (ATerm) SortSpec_0, (ATerm) ConsSpec_1, (ATerm) MapSpec_2, (ATerm) DataEqnSpec_3);
}

inline
ATermAppl gsMakeDataVarId(ATermAppl String_0, ATermAppl SortExpr_1)
{
  return ATmakeAppl2(gsAFunDataVarId(), (ATerm) String_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeDataVarIdInit(ATermAppl DataVarId_0, ATermAppl DataExpr_1)
{
  return ATmakeAppl2(gsAFunDataVarIdInit(), (ATerm) DataVarId_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeDelta()
{
  return ATmakeAppl0(gsAFunDelta());
}

inline
ATermAppl gsMakeExists()
{
  return ATmakeAppl0(gsAFunExists());
}

inline
ATermAppl gsMakeForall()
{
  return ATmakeAppl0(gsAFunForall());
}

inline
ATermAppl gsMakeGlobVarSpec(ATermList DataVarId_0)
{
  return ATmakeAppl1(gsAFunGlobVarSpec(), (ATerm) DataVarId_0);
}

inline
ATermAppl gsMakeHide(ATermList String_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunHide(), (ATerm) String_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeId(ATermAppl String_0)
{
  return ATmakeAppl1(gsAFunId(), (ATerm) String_0);
}

inline
ATermAppl gsMakeIdAssignment(ATermAppl String_0, ATermList IdInit_1)
{
  return ATmakeAppl2(gsAFunIdAssignment(), (ATerm) String_0, (ATerm) IdInit_1);
}

inline
ATermAppl gsMakeIdInit(ATermAppl String_0, ATermAppl DataExpr_1)
{
  return ATmakeAppl2(gsAFunIdInit(), (ATerm) String_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeIfThen(ATermAppl DataExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunIfThen(), (ATerm) DataExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeIfThenElse(ATermAppl DataExpr_0, ATermAppl ProcExpr_1, ATermAppl ProcExpr_2)
{
  return ATmakeAppl3(gsAFunIfThenElse(), (ATerm) DataExpr_0, (ATerm) ProcExpr_1, (ATerm) ProcExpr_2);
}

inline
ATermAppl gsMakeLMerge(ATermAppl ProcExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunLMerge(), (ATerm) ProcExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeLambda()
{
  return ATmakeAppl0(gsAFunLambda());
}

inline
ATermAppl gsMakeLinProcSpec(ATermAppl DataSpec_0, ATermAppl ActSpec_1, ATermAppl GlobVarSpec_2, ATermAppl LinearProcess_3, ATermAppl LinearProcessInit_4)
{
  return ATmakeAppl5(gsAFunLinProcSpec(), (ATerm) DataSpec_0, (ATerm) ActSpec_1, (ATerm) GlobVarSpec_2, (ATerm) LinearProcess_3, (ATerm) LinearProcessInit_4);
}

inline
ATermAppl gsMakeLinearProcess(ATermList DataVarId_0, ATermList LinearProcessSummand_1)
{
  return ATmakeAppl2(gsAFunLinearProcess(), (ATerm) DataVarId_0, (ATerm) LinearProcessSummand_1);
}

inline
ATermAppl gsMakeLinearProcessInit(ATermList DataVarIdInit_0)
{
  return ATmakeAppl1(gsAFunLinearProcessInit(), (ATerm) DataVarIdInit_0);
}

inline
ATermAppl gsMakeLinearProcessSummand(ATermList DataVarId_0, ATermAppl DataExpr_1, ATermAppl MultActOrDelta_2, ATermAppl DataExprOrNil_3, ATermList DataVarIdInit_4)
{
  return ATmakeAppl5(gsAFunLinearProcessSummand(), (ATerm) DataVarId_0, (ATerm) DataExpr_1, (ATerm) MultActOrDelta_2, (ATerm) DataExprOrNil_3, (ATerm) DataVarIdInit_4);
}

inline
ATermAppl gsMakeMapSpec(ATermList OpId_0)
{
  return ATmakeAppl1(gsAFunMapSpec(), (ATerm) OpId_0);
}

inline
ATermAppl gsMakeMerge(ATermAppl ProcExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunMerge(), (ATerm) ProcExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeMu()
{
  return ATmakeAppl0(gsAFunMu());
}

inline
ATermAppl gsMakeMultAct(ATermList ParamIdOrAction_0)
{
  return ATmakeAppl1(gsAFunMultAct(), (ATerm) ParamIdOrAction_0);
}

inline
ATermAppl gsMakeMultActName(ATermList String_0)
{
  return ATmakeAppl1(gsAFunMultActName(), (ATerm) String_0);
}

inline
ATermAppl gsMakeNil()
{
  return ATmakeAppl0(gsAFunNil());
}

inline
ATermAppl gsMakeNu()
{
  return ATmakeAppl0(gsAFunNu());
}

inline
ATermAppl gsMakeOpId(ATermAppl String_0, ATermAppl SortExpr_1)
{
  return ATmakeAppl2(gsAFunOpId(), (ATerm) String_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakePBES(ATermAppl DataSpec_0, ATermAppl GlobVarSpec_1, ATermAppl PBEqnSpec_2, ATermAppl PBInit_3)
{
  return ATmakeAppl4(gsAFunPBES(), (ATerm) DataSpec_0, (ATerm) GlobVarSpec_1, (ATerm) PBEqnSpec_2, (ATerm) PBInit_3);
}

inline
ATermAppl gsMakePBESAnd(ATermAppl PBExpr_0, ATermAppl PBExpr_1)
{
  return ATmakeAppl2(gsAFunPBESAnd(), (ATerm) PBExpr_0, (ATerm) PBExpr_1);
}

inline
ATermAppl gsMakePBESExists(ATermList DataVarId_0, ATermAppl PBExpr_1)
{
  return ATmakeAppl2(gsAFunPBESExists(), (ATerm) DataVarId_0, (ATerm) PBExpr_1);
}

inline
ATermAppl gsMakePBESFalse()
{
  return ATmakeAppl0(gsAFunPBESFalse());
}

inline
ATermAppl gsMakePBESForall(ATermList DataVarId_0, ATermAppl PBExpr_1)
{
  return ATmakeAppl2(gsAFunPBESForall(), (ATerm) DataVarId_0, (ATerm) PBExpr_1);
}

inline
ATermAppl gsMakePBESImp(ATermAppl PBExpr_0, ATermAppl PBExpr_1)
{
  return ATmakeAppl2(gsAFunPBESImp(), (ATerm) PBExpr_0, (ATerm) PBExpr_1);
}

inline
ATermAppl gsMakePBESNot(ATermAppl PBExpr_0)
{
  return ATmakeAppl1(gsAFunPBESNot(), (ATerm) PBExpr_0);
}

inline
ATermAppl gsMakePBESOr(ATermAppl PBExpr_0, ATermAppl PBExpr_1)
{
  return ATmakeAppl2(gsAFunPBESOr(), (ATerm) PBExpr_0, (ATerm) PBExpr_1);
}

inline
ATermAppl gsMakePBESTrue()
{
  return ATmakeAppl0(gsAFunPBESTrue());
}

inline
ATermAppl gsMakePBEqn(ATermAppl FixPoint_0, ATermAppl PropVarDecl_1, ATermAppl PBExpr_2)
{
  return ATmakeAppl3(gsAFunPBEqn(), (ATerm) FixPoint_0, (ATerm) PropVarDecl_1, (ATerm) PBExpr_2);
}

inline
ATermAppl gsMakePBEqnSpec(ATermList PBEqn_0)
{
  return ATmakeAppl1(gsAFunPBEqnSpec(), (ATerm) PBEqn_0);
}

inline
ATermAppl gsMakePBInit(ATermAppl PropVarInst_0)
{
  return ATmakeAppl1(gsAFunPBInit(), (ATerm) PropVarInst_0);
}

inline
ATermAppl gsMakeParamId(ATermAppl String_0, ATermList DataExpr_1)
{
  return ATmakeAppl2(gsAFunParamId(), (ATerm) String_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeProcEqn(ATermAppl ProcVarId_0, ATermList DataVarId_1, ATermAppl ProcExpr_2)
{
  return ATmakeAppl3(gsAFunProcEqn(), (ATerm) ProcVarId_0, (ATerm) DataVarId_1, (ATerm) ProcExpr_2);
}

inline
ATermAppl gsMakeProcEqnSpec(ATermList ProcEqn_0)
{
  return ATmakeAppl1(gsAFunProcEqnSpec(), (ATerm) ProcEqn_0);
}

inline
ATermAppl gsMakeProcSpec(ATermAppl DataSpec_0, ATermAppl ActSpec_1, ATermAppl GlobVarSpec_2, ATermAppl ProcEqnSpec_3, ATermAppl ProcInit_4)
{
  return ATmakeAppl5(gsAFunProcSpec(), (ATerm) DataSpec_0, (ATerm) ActSpec_1, (ATerm) GlobVarSpec_2, (ATerm) ProcEqnSpec_3, (ATerm) ProcInit_4);
}

inline
ATermAppl gsMakeProcVarId(ATermAppl String_0, ATermList SortExpr_1)
{
  return ATmakeAppl2(gsAFunProcVarId(), (ATerm) String_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeProcess(ATermAppl ProcVarId_0, ATermList DataExpr_1)
{



  ((ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)) ? static_cast<void> (0) : __assert_fail ("ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h", 3426, __PRETTY_FUNCTION__));



  ((ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)) ? static_cast<void> (0) : __assert_fail ("ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h", 3430, __PRETTY_FUNCTION__));



  ((ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)) ? static_cast<void> (0) : __assert_fail ("ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h", 3434, __PRETTY_FUNCTION__));



  ((ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)) ? static_cast<void> (0) : __assert_fail ("ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h", 3438, __PRETTY_FUNCTION__));



  ((ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)) ? static_cast<void> (0) : __assert_fail ("ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h", 3442, __PRETTY_FUNCTION__));



  ((ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)) ? static_cast<void> (0) : __assert_fail ("ATgetLength((ATermList)(((ATermAppl)ProcVarId_0)->aterm.arg[1]))==ATgetLength(DataExpr_1)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h", 3446, __PRETTY_FUNCTION__));
  return ATmakeAppl2(gsAFunProcess(), (ATerm) ProcVarId_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeProcessAssignment(ATermAppl ProcVarId_0, ATermList DataVarIdInit_1)
{
  return ATmakeAppl2(gsAFunProcessAssignment(), (ATerm) ProcVarId_0, (ATerm) DataVarIdInit_1);
}

inline
ATermAppl gsMakeProcessInit(ATermAppl ProcExpr_0)
{
  return ATmakeAppl1(gsAFunProcessInit(), (ATerm) ProcExpr_0);
}

inline
ATermAppl gsMakePropVarDecl(ATermAppl String_0, ATermList DataVarId_1)
{
  return ATmakeAppl2(gsAFunPropVarDecl(), (ATerm) String_0, (ATerm) DataVarId_1);
}

inline
ATermAppl gsMakePropVarInst(ATermAppl String_0, ATermList DataExpr_1)
{
  return ATmakeAppl2(gsAFunPropVarInst(), (ATerm) String_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeRegAlt(ATermAppl RegFrm_0, ATermAppl RegFrm_1)
{
  return ATmakeAppl2(gsAFunRegAlt(), (ATerm) RegFrm_0, (ATerm) RegFrm_1);
}

inline
ATermAppl gsMakeRegNil()
{
  return ATmakeAppl0(gsAFunRegNil());
}

inline
ATermAppl gsMakeRegSeq(ATermAppl RegFrm_0, ATermAppl RegFrm_1)
{
  return ATmakeAppl2(gsAFunRegSeq(), (ATerm) RegFrm_0, (ATerm) RegFrm_1);
}

inline
ATermAppl gsMakeRegTrans(ATermAppl RegFrm_0)
{
  return ATmakeAppl1(gsAFunRegTrans(), (ATerm) RegFrm_0);
}

inline
ATermAppl gsMakeRegTransOrNil(ATermAppl RegFrm_0)
{
  return ATmakeAppl1(gsAFunRegTransOrNil(), (ATerm) RegFrm_0);
}

inline
ATermAppl gsMakeRename(ATermList RenameExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunRename(), (ATerm) RenameExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeRenameExpr(ATermAppl String_0, ATermAppl String_1)
{
  return ATmakeAppl2(gsAFunRenameExpr(), (ATerm) String_0, (ATerm) String_1);
}

inline
ATermAppl gsMakeSeq(ATermAppl ProcExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunSeq(), (ATerm) ProcExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeSetBagComp()
{
  return ATmakeAppl0(gsAFunSetBagComp());
}

inline
ATermAppl gsMakeSetComp()
{
  return ATmakeAppl0(gsAFunSetComp());
}

inline
ATermAppl gsMakeSortArrow(ATermList SortExpr_0, ATermAppl SortExpr_1)
{
  return ATmakeAppl2(gsAFunSortArrow(), (ATerm) SortExpr_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeSortBag()
{
  return ATmakeAppl0(gsAFunSortBag());
}

inline
ATermAppl gsMakeSortCons(ATermAppl SortConsType_0, ATermAppl SortExpr_1)
{
  return ATmakeAppl2(gsAFunSortCons(), (ATerm) SortConsType_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeSortFBag()
{
  return ATmakeAppl0(gsAFunSortFBag());
}

inline
ATermAppl gsMakeSortFSet()
{
  return ATmakeAppl0(gsAFunSortFSet());
}

inline
ATermAppl gsMakeSortId(ATermAppl String_0)
{
  return ATmakeAppl1(gsAFunSortId(), (ATerm) String_0);
}

inline
ATermAppl gsMakeSortList()
{
  return ATmakeAppl0(gsAFunSortList());
}

inline
ATermAppl gsMakeSortRef(ATermAppl String_0, ATermAppl SortExpr_1)
{
  return ATmakeAppl2(gsAFunSortRef(), (ATerm) String_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeSortSet()
{
  return ATmakeAppl0(gsAFunSortSet());
}

inline
ATermAppl gsMakeSortSpec(ATermList SortDecl_0)
{
  return ATmakeAppl1(gsAFunSortSpec(), (ATerm) SortDecl_0);
}

inline
ATermAppl gsMakeSortStruct(ATermList StructCons_0)
{
  return ATmakeAppl1(gsAFunSortStruct(), (ATerm) StructCons_0);
}

inline
ATermAppl gsMakeSortUnknown()
{
  return ATmakeAppl0(gsAFunSortUnknown());
}

inline
ATermAppl gsMakeSortsPossible(ATermList SortExpr_0)
{
  return ATmakeAppl1(gsAFunSortsPossible(), (ATerm) SortExpr_0);
}

inline
ATermAppl gsMakeStateAnd(ATermAppl StateFrm_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateAnd(), (ATerm) StateFrm_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateDelay()
{
  return ATmakeAppl0(gsAFunStateDelay());
}

inline
ATermAppl gsMakeStateDelayTimed(ATermAppl DataExpr_0)
{
  return ATmakeAppl1(gsAFunStateDelayTimed(), (ATerm) DataExpr_0);
}

inline
ATermAppl gsMakeStateExists(ATermList DataVarId_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateExists(), (ATerm) DataVarId_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateFalse()
{
  return ATmakeAppl0(gsAFunStateFalse());
}

inline
ATermAppl gsMakeStateForall(ATermList DataVarId_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateForall(), (ATerm) DataVarId_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateImp(ATermAppl StateFrm_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateImp(), (ATerm) StateFrm_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateMay(ATermAppl RegFrm_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateMay(), (ATerm) RegFrm_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateMu(ATermAppl String_0, ATermList DataVarIdInit_1, ATermAppl StateFrm_2)
{
  return ATmakeAppl3(gsAFunStateMu(), (ATerm) String_0, (ATerm) DataVarIdInit_1, (ATerm) StateFrm_2);
}

inline
ATermAppl gsMakeStateMust(ATermAppl RegFrm_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateMust(), (ATerm) RegFrm_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateNot(ATermAppl StateFrm_0)
{
  return ATmakeAppl1(gsAFunStateNot(), (ATerm) StateFrm_0);
}

inline
ATermAppl gsMakeStateNu(ATermAppl String_0, ATermList DataVarIdInit_1, ATermAppl StateFrm_2)
{
  return ATmakeAppl3(gsAFunStateNu(), (ATerm) String_0, (ATerm) DataVarIdInit_1, (ATerm) StateFrm_2);
}

inline
ATermAppl gsMakeStateOr(ATermAppl StateFrm_0, ATermAppl StateFrm_1)
{
  return ATmakeAppl2(gsAFunStateOr(), (ATerm) StateFrm_0, (ATerm) StateFrm_1);
}

inline
ATermAppl gsMakeStateTrue()
{
  return ATmakeAppl0(gsAFunStateTrue());
}

inline
ATermAppl gsMakeStateVar(ATermAppl String_0, ATermList DataExpr_1)
{
  return ATmakeAppl2(gsAFunStateVar(), (ATerm) String_0, (ATerm) DataExpr_1);
}

inline
ATermAppl gsMakeStateYaled()
{
  return ATmakeAppl0(gsAFunStateYaled());
}

inline
ATermAppl gsMakeStateYaledTimed(ATermAppl DataExpr_0)
{
  return ATmakeAppl1(gsAFunStateYaledTimed(), (ATerm) DataExpr_0);
}

inline
ATermAppl gsMakeStructCons(ATermAppl String_0, ATermList StructProj_1, ATermAppl StringOrNil_2)
{
  return ATmakeAppl3(gsAFunStructCons(), (ATerm) String_0, (ATerm) StructProj_1, (ATerm) StringOrNil_2);
}

inline
ATermAppl gsMakeStructProj(ATermAppl StringOrNil_0, ATermAppl SortExpr_1)
{
  return ATmakeAppl2(gsAFunStructProj(), (ATerm) StringOrNil_0, (ATerm) SortExpr_1);
}

inline
ATermAppl gsMakeSum(ATermList DataVarId_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunSum(), (ATerm) DataVarId_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeSync(ATermAppl ProcExpr_0, ATermAppl ProcExpr_1)
{
  return ATmakeAppl2(gsAFunSync(), (ATerm) ProcExpr_0, (ATerm) ProcExpr_1);
}

inline
ATermAppl gsMakeTau()
{
  return ATmakeAppl0(gsAFunTau());
}

inline
ATermAppl gsMakeWhr(ATermAppl DataExpr_0, ATermList WhrDecl_1)
{
  return ATmakeAppl2(gsAFunWhr(), (ATerm) DataExpr_0, (ATerm) WhrDecl_1);
}





inline
ATermAppl gsString2ATermAppl(const char *s)


{
  if (s != __null) {
    return ATmakeAppl0(ATmakeAFun(s, 0, ATtrue));
  } else {
    return gsMakeNil();
  }
}

inline
bool gsIsString(ATermAppl term)

{
  AFun head = ((AFun)(((term)->header) >> 34));
  return ((((unsigned int)((unsigned long)((at_lookup_table_alias[(head)]->header) >> 34))) == 0) && ((((at_lookup_table_alias[(head)]->header) & (1<<3)) ? ATtrue : ATfalse) == ATtrue));
}

inline
char *gsATermAppl2String(ATermAppl term)


{
  if (gsIsString(term)) {
    return (at_lookup_table[(((AFun)(((term)->header) >> 34)))]->name);
  } else {
    return __null;
  }
}

inline
bool gsIsNumericString(const char* s)

{
  if (s == __null) return false;
  if (s[0] == '\0') return false;
  if (s[0] == '-') ++s;
  if (s[0] == '\0') return false;
  if (s[0] == '0') {
    ++s;
    if (s[0] == '\0') return true;
    else return false;
  }
  for (; s[0] != '\0'; ++s)
    if(!isdigit(s[0])) return false;
  return true;
}

ATermAppl gsFreshString2ATermAppl(const char *s, ATerm Term, bool TryNoSuffix);
# 3815 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h"
inline
bool gsIsSortExpr(ATermAppl Term)
{
  return
    gsIsSortId(Term) || gsIsSortCons(Term) ||
    gsIsSortStruct(Term) || gsIsSortArrow(Term) ||
    gsIsSortUnknown(Term) || gsIsSortsPossible(Term);
}



inline
bool gsIsDataExpr(ATermAppl Term)
{
  return gsIsId(Term) || gsIsDataVarId(Term) || gsIsOpId(Term) ||
    gsIsDataAppl(Term) || gsIsBinder(Term) || gsIsWhr(Term);
}


inline
bool gsIsStateFrm(ATermAppl Term)
{
  return gsIsDataExpr(Term)
      || gsIsStateTrue(Term)
      || gsIsStateFalse(Term)
      || gsIsStateNot(Term)
      || gsIsStateAnd(Term)
      || gsIsStateOr(Term)
      || gsIsStateImp(Term)
      || gsIsStateForall(Term)
      || gsIsStateExists(Term)
      || gsIsStateMust(Term)
      || gsIsStateMay(Term)
      || gsIsStateYaled(Term)
      || gsIsStateYaledTimed(Term)
      || gsIsStateDelay(Term)
      || gsIsStateDelayTimed(Term)
      || gsIsStateVar(Term)
      || gsIsStateNu(Term)
      || gsIsStateMu(Term);
}



inline
bool gsIsActFrm(ATermAppl Term)
{
  return
    gsIsMultAct(Term) || gsIsDataExpr(Term) || gsIsActTrue(Term) ||
    gsIsActFalse(Term) || gsIsActNot(Term) || gsIsActAnd(Term) ||
    gsIsActOr(Term) || gsIsActImp(Term) || gsIsActForall(Term) ||
    gsIsActExists(Term) || gsIsActAt(Term);
}



inline
bool gsIsRegFrm(ATermAppl Term)
{
  return
    gsIsActFrm(Term) || gsIsRegNil(Term) || gsIsRegSeq(Term) ||
    gsIsRegAlt(Term) || gsIsRegTrans(Term) || gsIsRegTransOrNil(Term);
}



inline
bool gsIsProcExpr(ATermAppl Term)
{
  return gsIsParamId(Term)
      || gsIsIdAssignment(Term)
      || gsIsAction(Term)
      || gsIsProcess(Term)
      || gsIsProcessAssignment(Term)
      || gsIsDelta(Term)
      || gsIsTau (Term)
      || gsIsSum(Term)
      || gsIsBlock(Term)
      || gsIsHide(Term)
      || gsIsRename(Term)
      || gsIsComm(Term)
      || gsIsAllow(Term)
      || gsIsSync(Term)
      || gsIsAtTime(Term)
      || gsIsSeq(Term)
      || gsIsIfThen(Term)
      || gsIsIfThenElse(Term)
      || gsIsBInit(Term)
      || gsIsMerge(Term)
      || gsIsLMerge(Term)
      || gsIsChoice(Term);
}






inline
bool gsIsPBExpr(ATermAppl Term)
{
  return gsIsDataExpr(Term)
      || gsIsPBESTrue(Term)
      || gsIsPBESFalse(Term)
      || gsIsPBESNot(Term)
      || gsIsPBESAnd(Term)
      || gsIsPBESOr(Term)
      || gsIsPBESImp(Term)
      || gsIsPBESForall(Term)
      || gsIsPBESExists(Term)
      || gsIsPropVarInst(Term)
  ;
}



inline
bool gsIsFixpoint(ATermAppl Term)
{
  return gsIsMu(Term) || gsIsNu(Term);
}




ATermAppl gsSortMultAct(ATermAppl MultAct);


    }
  }
}
# 33 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h"
# 1 "/usr/include/boost/utility.hpp" 1 3 4
# 12 "/usr/include/boost/utility.hpp" 3 4
# 1 "/usr/include/boost/utility/addressof.hpp" 1 3 4
# 18 "/usr/include/boost/utility/addressof.hpp" 3 4
namespace boost
{

namespace detail
{

template<class T> struct addr_impl_ref
{
    T & v_;

    inline addr_impl_ref( T & v ): v_( v ) {}
    inline operator T& () const { return v_; }

private:
    addr_impl_ref & operator=(const addr_impl_ref &);
};

template<class T> struct addressof_impl
{
    static inline T * f( T & v, long )
    {
        return reinterpret_cast<T*>(
            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
    }

    static inline T * f( T * v, int )
    {
        return v;
    }
};

}

template<class T> T * addressof( T & v )
{






    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );


}
# 100 "/usr/include/boost/utility/addressof.hpp" 3 4
}
# 13 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/utility/base_from_member.hpp" 1 3 4
# 14 "/usr/include/boost/utility/base_from_member.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3 4
# 15 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
# 16 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 41 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/list/adt.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/check.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/compl.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
# 42 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 22 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 37 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/reverse.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
# 38 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 23 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 48 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
# 49 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4




# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
# 17 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 53 "/usr/include/boost/utility/base_from_member.hpp" 3 4
namespace boost
{
# 65 "/usr/include/boost/utility/base_from_member.hpp" 3 4
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 ) {}


};

}
# 14 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/utility/binary.hpp" 1 3 4
# 26 "/usr/include/boost/utility/binary.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/deduce_d.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/control/deduce_d.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/control/deduce_d.hpp" 2 3 4
# 27 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
# 28 "/usr/include/boost/utility/binary.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/seq/cat.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/seq/cat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/seq.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/seq/seq.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/elem.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/seq/seq.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/size.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/seq/cat.hpp" 2 3 4
# 30 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/transform.hpp" 1 3 4
# 31 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comparison/less_equal.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/comparison/less_equal.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/logical/not.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/comparison/less_equal.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 2 3 4
# 32 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 15 "/usr/include/boost/utility.hpp" 2 3 4

# 1 "/usr/include/boost/checked_delete.hpp" 1 3 4
# 24 "/usr/include/boost/checked_delete.hpp" 3 4
namespace boost
{



template<class T> inline void checked_delete(T * x)
{

    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete x;
}

template<class T> inline void checked_array_delete(T * x)
{
    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
    (void) sizeof(type_must_be_complete);
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {

        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const
    {
        boost::checked_array_delete(x);
    }
};

}
# 17 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/next_prior.hpp" 1 3 4
# 15 "/usr/include/boost/next_prior.hpp" 3 4
# 1 "/usr/include/c++/4.1.3/iterator" 1 3 4
# 63 "/usr/include/c++/4.1.3/iterator" 3 4
       
# 64 "/usr/include/c++/4.1.3/iterator" 3
# 72 "/usr/include/c++/4.1.3/iterator" 3
# 1 "/usr/include/c++/4.1.3/bits/stream_iterator.h" 1 3
# 38 "/usr/include/c++/4.1.3/bits/stream_iterator.h" 3
       
# 39 "/usr/include/c++/4.1.3/bits/stream_iterator.h" 3



namespace std
{

  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); }
# 150 "/usr/include/c++/4.1.3/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) {}
# 181 "/usr/include/c++/4.1.3/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; }
    };
}
# 73 "/usr/include/c++/4.1.3/iterator" 2 3
# 16 "/usr/include/boost/next_prior.hpp" 2 3 4

namespace boost {
# 29 "/usr/include/boost/next_prior.hpp" 3 4
template <class T>
inline T next(T x) { return ++x; }

template <class T, class Distance>
inline T next(T x, Distance n)
{
    std::advance(x, n);
    return x;
}

template <class T>
inline T prior(T x) { return --x; }

template <class T, class Distance>
inline T prior(T x, Distance n)
{
    std::advance(x, -n);
    return x;
}

}
# 18 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/noncopyable.hpp" 1 3 4
# 12 "/usr/include/boost/noncopyable.hpp" 3 4
namespace boost {






namespace noncopyable_
{
  class noncopyable
  {
   protected:
      noncopyable() {}
      ~noncopyable() {}
   private:
      noncopyable( const noncopyable& );
      const noncopyable& operator=( const noncopyable& );
  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 19 "/usr/include/boost/utility.hpp" 2 3 4
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/utilities/include/mcrl2/exception.h" 1
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 1
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_access.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_access.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 1
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_access.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h"
# 1 "/usr/include/c++/4.1.3/cassert" 1 3
# 47 "/usr/include/c++/4.1.3/cassert" 3
       
# 48 "/usr/include/c++/4.1.3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 49 "/usr/include/c++/4.1.3/cassert" 2 3
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 2
# 1 "/usr/include/c++/4.1.3/vector" 1 3
# 63 "/usr/include/c++/4.1.3/vector" 3
       
# 64 "/usr/include/c++/4.1.3/vector" 3






# 1 "/usr/include/c++/4.1.3/bits/stl_vector.h" 1 3
# 68 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
namespace std
{





  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;

      struct _Vector_impl
      : public _Tp_alloc_type
      {
 _Tp* _M_start;
 _Tp* _M_finish;
 _Tp* _M_end_of_storage;
 _Vector_impl(_Tp_alloc_type const& __a)
 : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
 { }
      };

    public:
      typedef _Alloc allocator_type;

      _Tp_alloc_type&
      _M_get_Tp_allocator()
      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }

      const _Tp_alloc_type&
      _M_get_Tp_allocator() const
      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }

      allocator_type
      get_allocator() const
      { return _M_get_Tp_allocator(); }

      _Vector_base(const allocator_type& __a)
      : _M_impl(__a)
      { }

      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      {
 this->_M_impl._M_start = this->_M_allocate(__n);
 this->_M_impl._M_finish = this->_M_impl._M_start;
 this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
      }

      ~_Vector_base()
      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
        - this->_M_impl._M_start); }

    public:
      _Vector_impl _M_impl;

      _Tp*
      _M_allocate(size_t __n)
      { return _M_impl.allocate(__n); }

      void
      _M_deallocate(_Tp* __p, size_t __n)
      {
 if (__p)
   _M_impl.deallocate(__p, __n);
      }
    };
# 157 "/usr/include/c++/4.1.3/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 vector<_Tp, _Alloc> vector_type;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;

    public:
      typedef _Tp value_type;
      typedef typename _Tp_alloc_type::pointer pointer;
      typedef typename _Tp_alloc_type::const_pointer const_pointer;
      typedef typename _Tp_alloc_type::reference reference;
      typedef typename _Tp_alloc_type::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type>
      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:





      explicit
      vector(const allocator_type& __a = allocator_type())
      : _Base(__a)
      { }
# 213 "/usr/include/c++/4.1.3/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)
      {
 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_start + __n;
      }
# 232 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      vector(const vector& __x)
      : _Base(__x.size(), __x.get_allocator())
      { this->_M_impl._M_finish =
   std::__uninitialized_copy_a(__x.begin(), __x.end(),
          this->_M_impl._M_start,
          _M_get_Tp_allocator());
      }
# 255 "/usr/include/c++/4.1.3/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());
 }







      ~vector()
      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator());
      }
# 284 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      vector&
      operator=(const vector& __x);
# 297 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 313 "/usr/include/c++/4.1.3/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());
 }


      using _Base::get_allocator;







      iterator
      begin()
      { return iterator (this->_M_impl._M_start); }






      const_iterator
      begin() const
      { return const_iterator (this->_M_impl._M_start); }






      iterator
      end()
      { return iterator (this->_M_impl._M_finish); }






      const_iterator
      end() const
      { return const_iterator (this->_M_impl._M_finish); }






      reverse_iterator
      rbegin()
      { return reverse_iterator(end()); }






      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(end()); }






      reverse_iterator
      rend()
      { return reverse_iterator(begin()); }






      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(begin()); }



      size_type
      size() const
      { return size_type(end() - begin()); }


      size_type
      max_size() const
      { return size_type(-1) / sizeof(value_type); }
# 420 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      void
      resize(size_type __new_size, value_type __x = value_type())
      {
 if (__new_size < size())
   erase(begin() + __new_size, end());
 else
   insert(end(), __new_size - size(), __x);
      }





      size_type
      capacity() const
      { return size_type(const_iterator(this->_M_impl._M_end_of_storage)
    - begin()); }





      bool
      empty() const
      { return begin() == end(); }
# 463 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      void
      reserve(size_type __n);
# 478 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      reference
      operator[](size_type __n)
      { return *(begin() + __n); }
# 493 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      const_reference
      operator[](size_type __n) const
      { return *(begin() + __n); }

    protected:

      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range(("vector::_M_range_check"));
      }

    public:
# 518 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 536 "/usr/include/c++/4.1.3/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); }
# 582 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      pointer
      data()
      { return pointer(this->_M_impl._M_start); }

      const_pointer
      data() const
      { return const_pointer(this->_M_impl._M_start); }
# 601 "/usr/include/c++/4.1.3/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)
   {
     this->_M_impl.construct(this->_M_impl._M_finish, __x);
     ++this->_M_impl._M_finish;
   }
 else
   _M_insert_aux(end(), __x);
      }
# 622 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      void
      pop_back()
      {
 --this->_M_impl._M_finish;
 this->_M_impl.destroy(this->_M_impl._M_finish);
      }
# 640 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      iterator
      insert(iterator __position, const value_type& __x);
# 656 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      void
      insert(iterator __position, size_type __n, const value_type& __x)
      { _M_fill_insert(__position, __n, __x); }
# 674 "/usr/include/c++/4.1.3/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());
 }
# 699 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      iterator
      erase(iterator __position);
# 720 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      iterator
      erase(iterator __first, iterator __last);
# 732 "/usr/include/c++/4.1.3/bits/stl_vector.h" 3
      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);
      }







      void
      clear()
      {
 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator());
 this->_M_impl._M_finish = this->_M_impl._M_start;
      }

    protected:






      template<typename _ForwardIterator>
        pointer
        _M_allocate_and_copy(size_type __n,
        _ForwardIterator __first, _ForwardIterator __last)
        {
   pointer __result = this->_M_allocate(__n);
   try
     {
       std::__uninitialized_copy_a(__first, __last, __result,
       _M_get_Tp_allocator());
       return __result;
     }
   catch(...)
     {
       _M_deallocate(__result, __n);
       throw;
     }
 }





      template<typename _Integer>
        void
        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
        {
   this->_M_impl._M_start = _M_allocate(__n);
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
   std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
     _M_get_Tp_allocator());
   this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
 }


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






      template<typename _Integer>
        void
        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
        {
   _M_fill_assign(static_cast<size_type>(__n),
    static_cast<value_type>(__val));
 }


      template<typename _InputIterator>
        void
        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_assign_aux(__first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag);



      void
      _M_fill_assign(size_type __n, const value_type& __val);





      template<typename _Integer>
        void
        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
      __true_type)
        {
   _M_fill_insert(__pos, static_cast<size_type>(__n),
    static_cast<value_type>(__val));
 }


      template<typename _InputIterator>
        void
        _M_insert_dispatch(iterator __pos, _InputIterator __first,
      _InputIterator __last, __false_type)
        {
   typedef typename std::iterator_traits<_InputIterator>::
     iterator_category _IterCategory;
   _M_range_insert(__pos, __first, __last, _IterCategory());
 }


      template<typename _InputIterator>
        void
        _M_range_insert(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
        void
        _M_range_insert(iterator __pos, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);



      void
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);


      void
      _M_insert_aux(iterator __position, const value_type& __x);
    };
# 930 "/usr/include/c++/4.1.3/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())); }
# 947 "/usr/include/c++/4.1.3/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); }
}
# 71 "/usr/include/c++/4.1.3/vector" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_bvector.h" 1 3
# 64 "/usr/include/c++/4.1.3/bits/stl_bvector.h" 3
namespace std
{
  typedef unsigned long _Bit_type;
  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };

  struct _Bit_reference
  {
    _Bit_type * _M_p;
    _Bit_type _M_mask;

    _Bit_reference(_Bit_type * __x, _Bit_type __y)
    : _M_p(__x), _M_mask(__y) { }

    _Bit_reference() : _M_p(0), _M_mask(0) { }

    operator bool() const
    { return !!(*_M_p & _M_mask); }

    _Bit_reference&
    operator=(bool __x)
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }

    _Bit_reference&
    operator=(const _Bit_reference& __x)
    { return *this = bool(__x); }

    bool
    operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }

    bool
    operator<(const _Bit_reference& __x) const
    { return !bool(*this) && bool(__x); }

    void
    flip()
    { *_M_p ^= _M_mask; }
  };

  struct _Bit_iterator_base
  : public std::iterator<std::random_access_iterator_tag, bool>
  {
    _Bit_type * _M_p;
    unsigned int _M_offset;

    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) { }

    void
    _M_bump_up()
    {
      if (_M_offset++ == int(_S_word_bit) - 1)
 {
   _M_offset = 0;
   ++_M_p;
 }
    }

    void
    _M_bump_down()
    {
      if (_M_offset-- == 0)
 {
   _M_offset = int(_S_word_bit) - 1;
   --_M_p;
 }
    }

    void
    _M_incr(ptrdiff_t __i)
    {
      difference_type __n = __i + _M_offset;
      _M_p += __n / int(_S_word_bit);
      __n = __n % int(_S_word_bit);
      if (__n < 0)
 {
   _M_offset = static_cast<unsigned int>(__n + int(_S_word_bit));
   --_M_p;
 }
      else
 _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; }

  template<class _Alloc>
    class _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(const _Bit_alloc_type& __a)
 : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
 { }
      };

    public:
      typedef _Alloc allocator_type;

      allocator_type
      get_allocator() const
      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }

      _Bvector_base(const allocator_type& __a) : _M_impl(__a) { }

      ~_Bvector_base()
      { this->_M_deallocate(); }

    protected:
      _Bvector_impl _M_impl;

      _Bit_type*
      _M_allocate(size_t __n)
      { return _M_impl.allocate((__n + int(_S_word_bit) - 1)
    / int(_S_word_bit)); }

      void
      _M_deallocate()
      {
 if (_M_impl._M_start._M_p)
   _M_impl.deallocate(_M_impl._M_start._M_p,
        _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
      }
    };
}




namespace std
{
# 425 "/usr/include/c++/4.1.3/bits/stl_bvector.h" 3
template<typename _Alloc>
  class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
  {
  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 typename _Bvector_base<_Alloc>::allocator_type allocator_type;

    allocator_type get_allocator() const
    { return _Bvector_base<_Alloc>::get_allocator(); }

  protected:
    using _Bvector_base<_Alloc>::_M_allocate;
    using _Bvector_base<_Alloc>::_M_deallocate;

  protected:
    void
    _M_initialize(size_type __n)
    {
      _Bit_type* __q = this->_M_allocate(__n);
      this->_M_impl._M_end_of_storage = (__q
      + ((__n + int(_S_word_bit) - 1)
         / int(_S_word_bit)));
      this->_M_impl._M_start = iterator(__q, 0);
      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
    }

    void
    _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 = size() ? 2 * size()
                                  : static_cast<size_type>(_S_word_bit);
   _Bit_type * __q = this->_M_allocate(__len);
   iterator __i = std::copy(begin(), __position, iterator(__q, 0));
   *__i++ = __x;
   this->_M_impl._M_finish = std::copy(__position, end(), __i);
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = (__q + ((__len
           + int(_S_word_bit) - 1)
          / int(_S_word_bit)));
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }

    template<class _InputIterator>
      void
      _M_initialize_range(_InputIterator __first, _InputIterator __last,
     std::input_iterator_tag)
      {
 this->_M_impl._M_start = iterator();
 this->_M_impl._M_finish = iterator();
 this->_M_impl._M_end_of_storage = 0;
 for (; __first != __last; ++__first)
   push_back(*__first);
      }

    template<class _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<class _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<class _ForwardIterator>
      void
      _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 = size() + std::max(size(), __n);
  _Bit_type * __q = this->_M_allocate(__len);
  iterator __i = std::copy(begin(), __position,
      iterator(__q, 0));
  __i = std::copy(__first, __last, __i);
  this->_M_impl._M_finish = std::copy(__position, end(), __i);
  this->_M_deallocate();
  this->_M_impl._M_end_of_storage = (__q
         + ((__len
             + int(_S_word_bit) - 1)
            / int(_S_word_bit)));
  this->_M_impl._M_start = iterator(__q, 0);
       }
   }
      }

  public:
    iterator
    begin()
    { return this->_M_impl._M_start; }

    const_iterator
    begin() const
    { return this->_M_impl._M_start; }

    iterator
    end()
    { return this->_M_impl._M_finish; }

    const_iterator
    end() const
    { return this->_M_impl._M_finish; }

    reverse_iterator
    rbegin()
    { return reverse_iterator(end()); }

    const_reverse_iterator
    rbegin() const
    { return const_reverse_iterator(end()); }

    reverse_iterator
    rend()
    { return reverse_iterator(begin()); }

    const_reverse_iterator
    rend() const
    { return const_reverse_iterator(begin()); }

    size_type
    size() const
    { return size_type(end() - begin()); }

    size_type
    max_size() const
    { return size_type(-1); }

    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 *(begin() + difference_type(__n)); }

    const_reference
    operator[](size_type __n) const
    { return *(begin() + difference_type(__n)); }

    void
    _M_range_check(size_type __n) const
    {
      if (__n >= this->size())
        __throw_out_of_range(("vector<bool>::_M_range_check"));
    }

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

    explicit
    vector(const allocator_type& __a = allocator_type())
    : _Bvector_base<_Alloc>(__a) { }

    vector(size_type __n, bool __value,
    const allocator_type& __a = allocator_type())
    : _Bvector_base<_Alloc>(__a)
    {
      _M_initialize(__n);
      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
  __value ? ~0 : 0);
    }

    explicit
    vector(size_type __n)
    : _Bvector_base<_Alloc>(allocator_type())
    {
      _M_initialize(__n);
      std::fill(this->_M_impl._M_start._M_p,
  this->_M_impl._M_end_of_storage, 0);
    }

    vector(const vector& __x)
    : _Bvector_base<_Alloc>(__x.get_allocator())
    {
      _M_initialize(__x.size());
      std::copy(__x.begin(), __x.end(), this->_M_impl._M_start);
    }


    template<class _Integer>
      void
      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
      {
 _M_initialize(__n);
 std::fill(this->_M_impl._M_start._M_p,
    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
      }

    template<class _InputIterator>
      void
      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
        __false_type)
      { _M_initialize_range(__first, __last,
       std::__iterator_category(__first)); }

    template<class _InputIterator>
      vector(_InputIterator __first, _InputIterator __last,
      const allocator_type& __a = allocator_type())
      : _Bvector_base<_Alloc>(__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());
 }
      std::copy(__x.begin(), __x.end(), begin());
      this->_M_impl._M_finish = begin() + difference_type(__x.size());
      return *this;
    }






    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
 {
   erase(begin() + __n, end());
   std::fill(this->_M_impl._M_start._M_p,
      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
 }
    }

    void
    assign(size_t __n, bool __x)
    { _M_fill_assign(__n, __x); }

    template<class _InputIterator>
      void
      assign(_InputIterator __first, _InputIterator __last)
      {
 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
 _M_assign_dispatch(__first, __last, _Integral());
      }

    template<class _Integer>
      void
      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
      { _M_fill_assign((size_t) __n, (bool) __val); }

    template<class _InputIterator>
      void
      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
    __false_type)
      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }

    template<class _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)
   erase(__cur, end());
 else
   insert(end(), __first, __last);
      }

    template<class _ForwardIterator>
      void
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __len = std::distance(__first, __last);
 if (__len < size())
   erase(std::copy(__first, __last, begin()), end());
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, begin());
     insert(end(), __mid, __last);
   }
      }

    void
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   _Bit_type* __q = this->_M_allocate(__n);
   this->_M_impl._M_finish = std::copy(begin(), end(),
           iterator(__q, 0));
   this->_M_deallocate();
   this->_M_impl._M_start = iterator(__q, 0);
   this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
          / int(_S_word_bit));
 }
    }

    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<bool, _Alloc>& __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);
    }


    static void
    swap(reference __x, reference __y)
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    iterator
    insert(iterator __position, bool __x = bool())
    {
      const difference_type __n = __position - begin();
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
   && __position == end())
        *this->_M_impl._M_finish++ = __x;
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }



    template<class _Integer>
      void
      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
    __true_type)
      { _M_fill_insert(__pos, __n, __x); }

    template<class _InputIterator>
      void
      _M_insert_dispatch(iterator __pos,
    _InputIterator __first, _InputIterator __last,
    __false_type)
      { _M_insert_range(__pos, __first, __last,
   std::__iterator_category(__first)); }

    template<class _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
    _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 = size() + std::max(size(), __n);
   _Bit_type * __q = this->_M_allocate(__len);
   iterator __i = std::copy(begin(), __position, iterator(__q, 0));
   std::fill_n(__i, __n, __x);
   this->_M_impl._M_finish = std::copy(__position, end(),
           __i + difference_type(__n));
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = (__q + ((__len
           + int(_S_word_bit) - 1)
          / int(_S_word_bit)));
   this->_M_impl._M_start = iterator(__q, 0);
 }
    }

    void
    insert(iterator __position, size_type __n, 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)
    {
      this->_M_impl._M_finish = std::copy(__last, end(), __first);
      return __first;
    }

    void
    resize(size_type __new_size, bool __x = bool())
    {
      if (__new_size < size())
        erase(begin() + difference_type(__new_size), end());
      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()
    { erase(begin(), end()); }
  };
}
# 72 "/usr/include/c++/4.1.3/vector" 2 3


# 1 "/usr/include/c++/4.1.3/bits/vector.tcc" 1 3
# 64 "/usr/include/c++/4.1.3/bits/vector.tcc" 3
namespace std
{
  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   const size_type __old_size = size();
   pointer __tmp = _M_allocate_and_copy(__n,
            this->_M_impl._M_start,
            this->_M_impl._M_finish);
   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
   _M_get_Tp_allocator());
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_finish = __tmp + __old_size;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
 }
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    insert(iterator __position, const value_type& __x)
    {
      const size_type __n = __position - begin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
   && __position == end())
 {
   this->_M_impl.construct(this->_M_impl._M_finish, __x);
   ++this->_M_impl._M_finish;
 }
      else
        _M_insert_aux(__position, __x);
      return begin() + __n;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    erase(iterator __position)
    {
      if (__position + 1 != end())
        std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      this->_M_impl.destroy(this->_M_impl._M_finish);
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    erase(iterator __first, iterator __last)
    {
      iterator __i(std::copy(__last, end(), __first));
      std::_Destroy(__i, end(), _M_get_Tp_allocator());
      this->_M_impl._M_finish = this->_M_impl._M_finish - (__last - __first);
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    vector<_Tp, _Alloc>&
    vector<_Tp, _Alloc>::
    operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (&__x != this)
 {
   const size_type __xlen = __x.size();
   if (__xlen > capacity())
     {
       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
         __x.end());
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __tmp;
       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
     }
   else if (size() >= __xlen)
     {
       iterator __i(std::copy(__x.begin(), __x.end(), begin()));
       std::_Destroy(__i, end(), _M_get_Tp_allocator());
     }
   else
     {
       std::copy(__x.begin(), __x.begin() + size(),
   this->_M_impl._M_start);
       std::__uninitialized_copy_a(__x.begin() + size(),
       __x.end(), 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
        erase(std::fill_n(begin(), __n, __val), end());
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      void
      vector<_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)
   erase(__cur, end());
 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)
   {
     iterator __new_finish(std::copy(__first, __last,
           this->_M_impl._M_start));
     std::_Destroy(__new_finish, end(), _M_get_Tp_allocator());
     this->_M_impl._M_finish = __new_finish.base();
   }
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, size());
     std::copy(__first, __mid, this->_M_impl._M_start);
     this->_M_impl._M_finish =
       std::__uninitialized_copy_a(__mid, __last,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
   }
      }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_insert_aux(iterator __position, const _Tp& __x)
    {
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 {
   this->_M_impl.construct(this->_M_impl._M_finish,
      *(this->_M_impl._M_finish - 1));
   ++this->_M_impl._M_finish;
   _Tp __x_copy = __x;
   std::copy_backward(__position,
        iterator(this->_M_impl._M_finish-2),
        iterator(this->_M_impl._M_finish-1));
   *__position = __x_copy;
 }
      else
 {
   const size_type __old_size = size();
   if (__old_size == this->max_size())
     __throw_length_error(("vector::_M_insert_aux"));




   size_type __len = __old_size != 0 ? 2 * __old_size : 1;
   if (__len < __old_size)
     __len = this->max_size();

   iterator __new_start(this->_M_allocate(__len));
   iterator __new_finish(__new_start);
   try
     {
       __new_finish =
  std::__uninitialized_copy_a(iterator(this->_M_impl._M_start),
         __position,
         __new_start,
         _M_get_Tp_allocator());
       this->_M_impl.construct(__new_finish.base(), __x);
       ++__new_finish;
       __new_finish =
  std::__uninitialized_copy_a(__position,
         iterator(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.base(),__len);
       throw;
     }
   std::_Destroy(begin(), end(), _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.base();
   this->_M_impl._M_finish = __new_finish.base();
   this->_M_impl._M_end_of_storage = __new_start.base() + __len;
 }
    }

  template<typename _Tp, typename _Alloc>
    void
    vector<_Tp, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
    {
      if (__n != 0)
 {
   if (size_type(this->_M_impl._M_end_of_storage
   - this->_M_impl._M_finish) >= __n)
     {
       value_type __x_copy = __x;
       const size_type __elems_after = end() - __position;
       iterator __old_finish(this->_M_impl._M_finish);
       if (__elems_after > __n)
  {
    std::__uninitialized_copy_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, __old_finish - __n,
         __old_finish);
    std::fill(__position, __position + __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_copy_a(__position, __old_finish,
           this->_M_impl._M_finish,
           _M_get_Tp_allocator());
    this->_M_impl._M_finish += __elems_after;
    std::fill(__position, __old_finish, __x_copy);
  }
     }
   else
     {
       const size_type __old_size = size();
       if (this->max_size() - __old_size < __n)
  __throw_length_error(("vector::_M_fill_insert"));


       size_type __len = __old_size + std::max(__old_size, __n);
       if (__len < __old_size)
  __len = this->max_size();

       iterator __new_start(this->_M_allocate(__len));
       iterator __new_finish(__new_start);
       try
  {
    __new_finish =
      std::__uninitialized_copy_a(begin(), __position,
      __new_start,
      _M_get_Tp_allocator());
    std::__uninitialized_fill_n_a(__new_finish, __n, __x,
      _M_get_Tp_allocator());
    __new_finish += __n;
    __new_finish =
      std::__uninitialized_copy_a(__position, end(), __new_finish,
      _M_get_Tp_allocator());
  }
       catch(...)
  {
    std::_Destroy(__new_start, __new_finish,
    _M_get_Tp_allocator());
    _M_deallocate(__new_start.base(), __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.base();
       this->_M_impl._M_finish = __new_finish.base();
       this->_M_impl._M_end_of_storage = __new_start.base() + __len;
     }
 }
    }

  template<typename _Tp, typename _Alloc> template<typename _InputIterator>
    void
    vector<_Tp, _Alloc>::
    _M_range_insert(iterator __pos, _InputIterator __first,
      _InputIterator __last, std::input_iterator_tag)
    {
      for (; __first != __last; ++__first)
 {
   __pos = insert(__pos, *__first);
   ++__pos;
 }
    }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     const size_type __n = std::distance(__first, __last);
     if (size_type(this->_M_impl._M_end_of_storage
     - this->_M_impl._M_finish) >= __n)
       {
  const size_type __elems_after = end() - __position;
  iterator __old_finish(this->_M_impl._M_finish);
  if (__elems_after > __n)
    {
      std::__uninitialized_copy_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, __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_copy_a(__position, __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 __old_size = size();
  if (this->max_size() - __old_size < __n)
    __throw_length_error(("vector::_M_range_insert"));


  size_type __len = __old_size + std::max(__old_size, __n);
  if (__len < __old_size)
    __len = this->max_size();

  iterator __new_start(this->_M_allocate(__len));
  iterator __new_finish(__new_start);
  try
    {
      __new_finish =
        std::__uninitialized_copy_a(iterator(this->_M_impl._M_start),
        __position,
        __new_start,
        _M_get_Tp_allocator());
      __new_finish =
        std::__uninitialized_copy_a(__first, __last, __new_finish,
        _M_get_Tp_allocator());
      __new_finish =
        std::__uninitialized_copy_a(__position,
        iterator(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.base(), __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.base();
  this->_M_impl._M_finish = __new_finish.base();
  this->_M_impl._M_end_of_storage = __new_start.base() + __len;
       }
   }
      }
}
# 75 "/usr/include/c++/4.1.3/vector" 2 3
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h"
# 1 "/usr/include/c++/4.1.3/cassert" 1 3
# 47 "/usr/include/c++/4.1.3/cassert" 3
       
# 48 "/usr/include/c++/4.1.3/cassert" 3

# 1 "/usr/include/assert.h" 1 3 4
# 49 "/usr/include/c++/4.1.3/cassert" 2 3
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 2

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

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

  template <class Category, class T, class Distance = std::ptrdiff_t,
            class Pointer = T*, class Reference = T&>
  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};

}
# 11 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/interoperable.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/interoperable.hpp" 3 4
# 1 "/usr/include/boost/mpl/or.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/or.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/or.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
    : T::type
{
};
}}}
# 24 "/usr/include/boost/mpl/or.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
# 1 "/usr/include/boost/mpl/lambda_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/lambda_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/void_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/void_fwd.hpp" 3 4
namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/na.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 3 4
namespace mpl_ {


struct na
{
    typedef na type;
    enum { value = 0 };
};

}
namespace boost { namespace mpl { using ::mpl_::na; } }
# 19 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4



namespace boost { namespace mpl {

template< typename T >
struct is_na
    : false_
{



};

template<>
struct is_na<na>
    : true_
{



};

template< typename T >
struct is_not_na
    : true_
{



};

template<>
struct is_not_na<na>
    : false_
{



};


template< typename T, typename U > struct if_na
{
    typedef T type;
};

template< typename U > struct if_na<na,U>
{
    typedef U type;
};
# 93 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
}}
# 19 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4


namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Arity = int_< aux::template_arity<T>::value >


    >
struct lambda;

}}
# 19 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/arity.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/arity.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/arity.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4




# 1 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
# 1 "/usr/include/boost/mpl/limits/arity.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4




# 1 "/usr/include/boost/preprocessor/logical/and.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/identity.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/empty.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 29 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
# 32 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 25 "/usr/include/boost/mpl/or.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/or.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 16 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/compiler.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/stringize.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct or_impl
    : true_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct or_impl< false,T1,T2,T3,T4 >
    : or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , false_
        >
{
};

template<>
struct or_impl<
          false
        , false_, false_, false_, false_
        >
    : false_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = false_, typename T4 = false_, typename T5 = false_
    >
struct or_

    : aux::or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{
   




};

template<> struct or_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }





}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/or.hpp" 2 3 4
# 12 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4



# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 16 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4

namespace boost
{
# 34 "/usr/include/boost/iterator/interoperable.hpp" 3 4
  template <typename A, typename B>
  struct is_interoperable



    : mpl::or_<
          is_convertible< A, B >
        , is_convertible< B, A > >

  {
  };

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 49 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
# 12 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_traits.hpp" 1 3 4







# 1 "/usr/include/boost/detail/iterator.hpp" 1 3 4
# 77 "/usr/include/boost/detail/iterator.hpp" 3 4
namespace boost { namespace detail {


template <class Iterator>
struct iterator_traits
    : std::iterator_traits<Iterator>
{};
using std::distance;

}}
# 9 "/usr/include/boost/iterator/iterator_traits.hpp" 2 3 4


namespace boost {
# 27 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
template <class Iterator>
struct iterator_value
{
    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
};

template <class Iterator>
struct iterator_reference
{
    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
};


template <class Iterator>
struct iterator_pointer
{
    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
};

template <class Iterator>
struct iterator_difference
{
    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
};

template <class Iterator>
struct iterator_category
{
    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
};
# 90 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
}
# 13 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4

# 1 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 1 3 4






# 1 "/usr/include/boost/iterator/iterator_categories.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/eval_if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/eval_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/if.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 73 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename T > struct value_type_wknd
{
    typedef typename T::value_type type;
};
# 87 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
}}}
# 18 "/usr/include/boost/mpl/if.hpp" 2 3 4







namespace boost { namespace mpl {



template<
      bool C
    , typename T1
    , typename T2
    >
struct if_c
{
    typedef T1 type;
};

template<
      typename T1
    , typename T2
    >
struct if_c<false,T1,T2>
{
    typedef T2 type;
};



template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = na
    >
struct if_
{
 private:

    typedef if_c<



          static_cast<bool>(T1::value)

        , T2
        , T3
        > almost_type_;

 public:
    typedef typename almost_type_::type type;

   
};
# 131 "/usr/include/boost/mpl/if.hpp" 3 4
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost/mpl/eval_if.hpp" 2 3 4






namespace boost { namespace mpl {

template<
      typename C = na
    , typename F1 = na
    , typename F2 = na
    >
struct eval_if




{
    typedef typename if_<C,F1,F2>::type f_;
    typedef typename f_::type type;




   
};



template<
      bool C
    , typename F1
    , typename F2
    >
struct eval_if_c




{
    typedef typename if_c<C,F1,F2>::type f_;
    typedef typename f_::type type;




};

template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }

}}
# 16 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/identity.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/identity.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename T = na
    >
struct identity
{
    typedef T type;
   
};

template<
      typename T = na
    >
struct make_identity
{
    typedef identity<T> type;
   
};

template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }

}}
# 17 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/arg.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/arg_fwd.hpp" 3 4
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/usr/include/boost/mpl/arg.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/na_assert.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/na_assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/assert.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/not.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/not.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template< long C_ >
struct not_impl
    : bool_<!C_>
{
};

}


template<
      typename T = na
    >
struct not_
    : aux::not_impl<
          ::boost::mpl::aux::nested_type_wknd<T>::value
        >
{
   
};

template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }

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


# 1 "/usr/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4




namespace boost { namespace mpl { namespace aux {

typedef char (&no_tag)[1];
typedef char (&yes_tag)[2];

template< bool C_ > struct yes_no_tag
{
    typedef no_tag type;
};

template<> struct yes_no_tag<true>
{
    typedef yes_tag type;
};


template< long n > struct weighted_tag
{

    typedef char (&type)[n];




};
# 56 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
}}}
# 21 "/usr/include/boost/mpl/assert.hpp" 2 3 4
# 29 "/usr/include/boost/mpl/assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/pp_counter.hpp" 1 3 4
# 30 "/usr/include/boost/mpl/assert.hpp" 2 3 4
# 62 "/usr/include/boost/mpl/assert.hpp" 3 4
namespace mpl_ {

struct failed {};
# 75 "/usr/include/boost/mpl/assert.hpp" 3 4
template< bool C > struct assert { typedef void* type; };
template<> struct assert<false> { typedef assert type; };

template< bool C >
int assertion_failed( typename assert<C>::type );

template< bool C >
struct assertion
{
    static int failed( assert<false> );
};

template<>
struct assertion<true>
{
    static int failed( void* );
};

struct assert_
{

    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};

    static assert_ const arg;
    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
};
# 123 "/usr/include/boost/mpl/assert.hpp" 3 4
boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );

template< assert_::relations r, long x, long y > struct assert_relation {};






template< bool > struct assert_arg_pred_impl { typedef int type; };
template<> struct assert_arg_pred_impl<true> { typedef void* type; };

template< typename P > struct assert_arg_pred
{
    typedef typename P::type p_type;
    typedef typename assert_arg_pred_impl< p_type::value >::type type;
};

template< typename P > struct assert_arg_pred_not
{
    typedef typename P::type p_type;
    enum { p = !p_type::value };
    typedef typename assert_arg_pred_impl<p>::type type;
};

template< typename Pred >
failed ************ (Pred::************
      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
    );

template< typename Pred >
failed ************ (boost::mpl::not_<Pred>::************
      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
    );

template< typename Pred >
assert<false>
assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );

template< typename Pred >
assert<false>
assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
# 212 "/usr/include/boost/mpl/assert.hpp" 3 4
}
# 24 "/usr/include/boost/mpl/aux_/na_assert.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/arity_spec.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/arg_typedef.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/arg.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 3 4
namespace mpl_ {
template<> struct arg< -1 >
{
    static const int value = -1;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<1>
{
    static const int value = 1;
    typedef arg<2> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<2>
{
    static const int value = 2;
    typedef arg<3> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U2 type;
        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<3>
{
    static const int value = 3;
    typedef arg<4> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U3 type;
        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<4>
{
    static const int value = 4;
    typedef arg<5> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U4 type;
        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};

template<> struct arg<5>
{
    static const int value = 5;
    typedef arg<6> next;
   
   

    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U5 type;
        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
    };
};



}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 38 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 25 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 3 4
namespace mpl_ {
typedef arg< -1 > _;
}
namespace boost { namespace mpl {

using ::mpl_::_;

namespace placeholders {
using mpl_::_;
}

}}



namespace mpl_ {
typedef arg<1> _1;

}
namespace boost { namespace mpl {

using ::mpl_::_1;

namespace placeholders {
using mpl_::_1;
}

}}
namespace mpl_ {
typedef arg<2> _2;

}
namespace boost { namespace mpl {

using ::mpl_::_2;

namespace placeholders {
using mpl_::_2;
}

}}
namespace mpl_ {
typedef arg<3> _3;

}
namespace boost { namespace mpl {

using ::mpl_::_3;

namespace placeholders {
using mpl_::_3;
}

}}
namespace mpl_ {
typedef arg<4> _4;

}
namespace boost { namespace mpl {

using ::mpl_::_4;

namespace placeholders {
using mpl_::_4;
}

}}
namespace mpl_ {
typedef arg<5> _5;

}
namespace boost { namespace mpl {

using ::mpl_::_5;

namespace placeholders {
using mpl_::_5;
}

}}
namespace mpl_ {
typedef arg<6> _6;

}
namespace boost { namespace mpl {

using ::mpl_::_6;

namespace placeholders {
using mpl_::_6;
}

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
# 18 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4






namespace boost {





struct no_traversal_tag {};

struct incrementable_traversal_tag
  : no_traversal_tag
{


};

struct single_pass_traversal_tag
  : incrementable_traversal_tag
{


};

struct forward_traversal_tag
  : single_pass_traversal_tag
{


};

struct bidirectional_traversal_tag
  : forward_traversal_tag
{


};

struct random_access_traversal_tag
  : bidirectional_traversal_tag
{


};

namespace detail
{






  template <class Cat>
  struct old_category_to_traversal
    : mpl::eval_if<
          is_convertible<Cat,std::random_access_iterator_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::eval_if<
              is_convertible<Cat,std::bidirectional_iterator_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::eval_if<
                  is_convertible<Cat,std::forward_iterator_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::eval_if<
                      is_convertible<Cat,std::input_iterator_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::eval_if<
                          is_convertible<Cat,std::output_iterator_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {};
# 108 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
  template <class Traversal>
  struct pure_traversal_tag
    : mpl::eval_if<
          is_convertible<Traversal,random_access_traversal_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::eval_if<
              is_convertible<Traversal,bidirectional_traversal_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::eval_if<
                  is_convertible<Traversal,forward_traversal_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::eval_if<
                      is_convertible<Traversal,single_pass_traversal_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::eval_if<
                          is_convertible<Traversal,incrementable_traversal_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {
  };
# 142 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
}





template <class Cat>
struct iterator_category_to_traversal
  : mpl::eval_if<
        is_convertible<Cat,incrementable_traversal_tag>
      , mpl::identity<Cat>
      , boost::detail::old_category_to_traversal<Cat>
    >
{};


template <class Iterator = mpl::_1>
struct iterator_traversal
  : iterator_category_to_traversal<
        typename boost::detail::iterator_traits<Iterator>::iterator_category
    >
{};
# 184 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 187 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 8 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/and.hpp" 1 3 4
# 42 "/usr/include/boost/mpl/and.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct and_impl
    : false_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct and_impl< true,T1,T2,T3,T4 >
    : and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , true_
        >
{
};

template<>
struct and_impl<
          true
        , true_, true_, true_, true_
        >
    : true_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = true_, typename T4 = true_, typename T5 = true_
    >
struct and_

    : aux::and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{
   




};

template<> struct and_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }





}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/and.hpp" 2 3 4
# 11 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/is_const.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/is_const.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 44 "/usr/include/boost/type_traits/is_const.hpp" 2 3 4

namespace boost {
# 57 "/usr/include/boost/type_traits/is_const.hpp" 3 4
   template< typename T > struct is_const : ::boost::integral_constant<bool,::boost::detail::cv_traits_imp<T*>::is_const> { };

template< typename T > struct is_const< T& > : ::boost::integral_constant<bool,false> { };
# 141 "/usr/include/boost/type_traits/is_const.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 144 "/usr/include/boost/type_traits/is_const.hpp" 2 3 4
# 18 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4





# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 24 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4


# 1 "/usr/include/boost/detail/indirect_traits.hpp" 1 3 4






# 1 "/usr/include/boost/type_traits/is_function.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_function.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/false_result.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/false_result.hpp" 3 4
namespace boost {
namespace type_traits {


struct false_result
{
    template <typename T> struct result_
    {
        static const bool value = false;
    };
};

}}
# 16 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
namespace boost {
namespace type_traits {

template <class R>
struct is_function_ptr_helper
{
    static const bool value = false;
};




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

template <class R >
struct is_function_ptr_helper<R (*)( ...)> { static const bool value = true; };

template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0)> { static const bool value = true; };

template <class R , class T0>
struct is_function_ptr_helper<R (*)( T0 ...)> { static const bool value = true; };

template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1)> { static const bool value = true; };

template <class R , class T0 , class T1>
struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { static const bool value = true; };

template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { static const bool value = true; };
# 203 "/usr/include/boost/type_traits/detail/is_function_ptr_helper.hpp" 3 4
}
}
# 20 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4







namespace boost {



namespace detail {


template<bool is_ref = true>
struct is_function_chooser
    : ::boost::type_traits::false_result
{
};

template <>
struct is_function_chooser<false>
{
    template< typename T > struct result_
        : ::boost::type_traits::is_function_ptr_helper<T*>
    {
    };
};

template <typename T>
struct is_function_impl
    : is_function_chooser< ::boost::is_reference<T>::value >
        ::template result_<T>
{
};
# 90 "/usr/include/boost/type_traits/is_function.hpp" 3 4
}






template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 102 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
# 8 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/is_pointer.hpp" 1 3 4
# 24 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
# 28 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
# 24 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
namespace boost {
namespace type_traits {

template <typename T>
struct is_mem_fun_pointer_impl
{
    static const bool value = false;
};





template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };



template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };


template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };

template <class R, class T >
struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };



template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };


template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0>
struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };



template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };


template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };

template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
# 776 "/usr/include/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 3 4
}
}
# 25 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
# 36 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 37 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4

namespace boost {





template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> { };
# 132 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
}

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

namespace boost {
# 50 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { };
template< typename T, typename U > struct is_member_pointer< U T::* > : ::boost::integral_constant<bool,true> { };


template< typename T, typename U > struct is_member_pointer< U T::*const > : ::boost::integral_constant<bool,true> { };
template< typename T, typename U > struct is_member_pointer< U T::*volatile > : ::boost::integral_constant<bool,true> { };
template< typename T, typename U > struct is_member_pointer< U T::*const volatile > : ::boost::integral_constant<bool,true> { };
# 112 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
}

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

namespace boost {





namespace detail {

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



template< typename T >
struct is_pointer_impl
{
# 80 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value);
# 89 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
};

}

template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { };
# 158 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 161 "/usr/include/boost/type_traits/is_pointer.hpp" 2 3 4
# 10 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/is_volatile.hpp" 1 3 4
# 40 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 41 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4

namespace boost {
# 52 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
   template< typename T > struct is_volatile : ::boost::integral_constant<bool,::boost::detail::cv_traits_imp<T*>::is_volatile> { };

template< typename T > struct is_volatile< T& > : ::boost::integral_constant<bool,false> { };
# 129 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 132 "/usr/include/boost/type_traits/is_volatile.hpp" 2 3 4
# 13 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/remove_reference.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/remove_reference.hpp" 2 3 4

namespace boost {



template< typename T > struct remove_reference { typedef T type; };
template< typename T > struct remove_reference<T&> { typedef T type; };
# 46 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 49 "/usr/include/boost/type_traits/remove_reference.hpp" 2 3 4
# 17 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_pointer.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/remove_pointer.hpp" 2 3 4

namespace boost {



template< typename T > struct remove_pointer { typedef T type; };
template< typename T > struct remove_pointer<T*> { typedef T type; };
template< typename T > struct remove_pointer<T* const> { typedef T type; };
template< typename T > struct remove_pointer<T* volatile> { typedef T type; };
template< typename T > struct remove_pointer<T* const volatile> { typedef T type; };







}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 42 "/usr/include/boost/type_traits/remove_pointer.hpp" 2 3 4
# 18 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
# 33 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
namespace boost { namespace detail {

namespace indirect_traits {


template <class T>
struct is_reference_to_const : mpl::false_
{
};

template <class T>
struct is_reference_to_const<T const&> : mpl::true_
{
};
# 55 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
template <class T>
struct is_reference_to_function : mpl::false_
{
};

template <class T>
struct is_reference_to_function<T&> : is_function<T>
{
};

template <class T>
struct is_pointer_to_function : mpl::false_
{
};



template <class T>
struct is_pointer_to_function<T*> : is_function<T>
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl : mpl::false_
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl<T&>
    : is_member_function_pointer<typename remove_cv<T>::type>
{
};


template <class T>
struct is_reference_to_member_function_pointer
    : is_reference_to_member_function_pointer_impl<T>
{
   
};

template <class T>
struct is_reference_to_function_pointer_aux
    : mpl::and_<
          is_reference<T>
        , is_pointer_to_function<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >
      >
{

};

template <class T>
struct is_reference_to_function_pointer
    : mpl::if_<
          is_reference_to_function<T>
        , mpl::false_
        , is_reference_to_function_pointer_aux<T>
     >::type
{
};

template <class T>
struct is_reference_to_non_const
    : mpl::and_<
          is_reference<T>
        , mpl::not_<
             is_reference_to_const<T>
          >
      >
{
};

template <class T>
struct is_reference_to_volatile : mpl::false_
{
};

template <class T>
struct is_reference_to_volatile<T volatile&> : mpl::true_
{
};
# 149 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
template <class T>
struct is_reference_to_pointer : mpl::false_
{
};

template <class T>
struct is_reference_to_pointer<T*&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* const&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* volatile&> : mpl::true_
{
};

template <class T>
struct is_reference_to_pointer<T* const volatile&> : mpl::true_
{
};

template <class T>
struct is_reference_to_class
    : mpl::and_<
          is_reference<T>
        , is_class<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >
      >
{
   
};

template <class T>
struct is_pointer_to_class
    : mpl::and_<
          is_pointer<T>
        , is_class<
              typename remove_cv<
                  typename remove_pointer<T>::type
              >::type
          >
      >
{
   
};
# 481 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
}

using namespace indirect_traits;

}}
# 27 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4







namespace boost { struct use_default; }

namespace boost { namespace detail {

struct input_output_iterator_tag
  : std::input_iterator_tag
{






    operator std::output_iterator_tag() const
    {
        return std::output_iterator_tag();
    }
};






template <class ValueParam, class Reference>
struct iterator_writability_disabled

  : mpl::or_<
        is_const<Reference>
      , boost::detail::indirect_traits::is_reference_to_const<Reference>
      , is_const<ValueParam>
    >



{};
# 86 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
  : mpl::eval_if<
        mpl::and_<
            is_reference<Reference>
          , is_convertible<Traversal,forward_traversal_tag>
        >
      , mpl::eval_if<
            is_convertible<Traversal,random_access_traversal_tag>
          , mpl::identity<std::random_access_iterator_tag>
          , mpl::if_<
                is_convertible<Traversal,bidirectional_traversal_tag>
              , std::bidirectional_iterator_tag
              , std::forward_iterator_tag
            >
        >
      , typename mpl::eval_if<
            mpl::and_<
                is_convertible<Traversal, single_pass_traversal_tag>


              , is_convertible<Reference, ValueParam>
            >
          , mpl::identity<std::input_iterator_tag>
          , mpl::identity<Traversal>
        >
    >
{
};


template <class T>
struct is_iterator_category
  : mpl::or_<
        is_convertible<T,std::input_iterator_tag>
      , is_convertible<T,std::output_iterator_tag>
    >
{
};

template <class T>
struct is_iterator_traversal
  : is_convertible<T,incrementable_traversal_tag>
{};







template <class Category, class Traversal>
struct iterator_category_with_traversal
  : Category, Traversal
{




    enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) };





    enum { mpl_assertion_in_line_151 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
    enum { mpl_assertion_in_line_152 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
    enum { mpl_assertion_in_line_153 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };

    enum { mpl_assertion_in_line_155 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };


};



template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{

    enum { mpl_assertion_in_line_166 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };


    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
    >::type category;

    typedef typename mpl::if_<
        is_same<
            Traversal
          , typename iterator_category_to_traversal<category>::type
        >
      , category
      , iterator_category_with_traversal<category,Traversal>
    >::type type;
};




template <class CategoryOrTraversal, class ValueParam, class Reference>
struct facade_iterator_category
  : mpl::eval_if<
        is_iterator_category<CategoryOrTraversal>
      , mpl::identity<CategoryOrTraversal>
      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
    >
{
};

}}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 199 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
# 15 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/detail/enable_if.hpp" 1 3 4
# 13 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 14 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4







namespace boost
{

  namespace iterators
  {



    template<bool>
    struct enabled
    {
      template<typename T>
      struct base
      {
        typedef T type;
      };
    };






    template<>
    struct enabled<false>
    {
      template<typename T>
      struct base
      {
# 62 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
      };
    };


    template <class Cond,
              class Return>
    struct enable_if

      : enabled<(Cond::value)>::template base<Return>



    {



    };

  }

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 85 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
# 16 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4

# 1 "/usr/include/boost/implicit_cast.hpp" 1 3 4
# 10 "/usr/include/boost/implicit_cast.hpp" 3 4
namespace boost {






template <typename T>
inline T implicit_cast (typename mpl::identity<T>::type x) {
    return x;
}





}
# 18 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/add_const.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/add_const.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4

namespace boost {
# 33 "/usr/include/boost/type_traits/add_const.hpp" 3 4
template< typename T > struct add_const { typedef T const type; };






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


}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 46 "/usr/include/boost/type_traits/add_const.hpp" 2 3 4
# 22 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_pointer.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4

namespace boost {

namespace detail {
# 55 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
template <typename T>
struct add_pointer_impl
{
    typedef typename remove_reference<T>::type no_ref_type;
    typedef no_ref_type* type;
};



}

template< typename T > struct add_pointer { typedef typename boost::detail::add_pointer_impl<T>::type type; };

}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 71 "/usr/include/boost/type_traits/add_pointer.hpp" 2 3 4
# 23 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_const.hpp" 1 3 4
# 27 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 28 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4

namespace boost {



namespace detail {

template <typename T, bool is_vol>
struct remove_const_helper
{
    typedef T type;
};

template <typename T>
struct remove_const_helper<T, true>
{
    typedef T volatile type;
};


template <typename T>
struct remove_const_impl
{
    typedef typename remove_const_helper<
          typename cv_traits_imp<T*>::unqualified_type
        , ::boost::is_volatile<T>::value
        >::type type;
};

}



template< typename T > struct remove_const { typedef typename boost::detail::remove_const_impl<T>::type type; };
template< typename T > struct remove_const<T&> { typedef T& type; };

template< typename T, std::size_t N > struct remove_const<T const[N]> { typedef T type[N]; };
template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { typedef T volatile type[N]; };
# 74 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 77 "/usr/include/boost/type_traits/remove_const.hpp" 2 3 4
# 24 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/is_pod.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_scalar.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_scalar.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_enum.hpp" 1 3 4
# 32 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 33 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4

namespace boost {




namespace detail {



template <typename T>
struct is_class_or_union
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_class<T>::value , ::boost::is_union<T>::value >::value);




};
# 78 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
struct int_convertible
{
    int_convertible(int);
};



template <bool is_typename_arithmetic_or_reference = true>
struct is_enum_helper
{
    template <typename T> struct type
    {
        static const bool value = false;
    };
};

template <>
struct is_enum_helper<false>
{
    template <typename T> struct type
       : ::boost::is_convertible<typename boost::add_reference<T>::type,::boost::detail::int_convertible>
    {
    };
};

template <typename T> struct is_enum_impl
{
# 115 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
   static const bool selector = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value , ::boost::is_reference<T>::value , ::boost::is_function<T>::value , is_class_or_union<T>::value , is_array<T>::value >::value);
# 152 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
    typedef ::boost::detail::is_enum_helper<selector> se_t;


    typedef typename se_t::template type<T> helper;
    static const bool value = helper::value;
};


template<> struct is_enum_impl< void > { static const bool value = (false); };

template<> struct is_enum_impl< void const > { static const bool value = (false); };
template<> struct is_enum_impl< void volatile > { static const bool value = (false); };
template<> struct is_enum_impl< void const volatile > { static const bool value = (false); };


}

template< typename T > struct is_enum : ::boost::integral_constant<bool,::boost::detail::is_enum_impl<T>::value> { };
# 185 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 188 "/usr/include/boost/type_traits/is_enum.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 21 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4

namespace boost {

namespace detail {

template <typename T>
struct is_scalar_impl
{
   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value);






};



template <> struct is_scalar_impl<void>{ static const bool value = false; };

template <> struct is_scalar_impl<void const>{ static const bool value = false; };
template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };


}

template< typename T > struct is_scalar : ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 54 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 22 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4

namespace boost {


template< typename T > struct is_POD;

namespace detail {



template <typename T> struct is_pod_impl
{
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, false >::value);






};


template <typename T, std::size_t sz>
struct is_pod_impl<T[sz]>
    : is_pod_impl<T>
{
};
# 118 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
template<> struct is_pod_impl< void > { static const bool value = (true); };


template<> struct is_pod_impl< void const > { static const bool value = (true); };
template<> struct is_pod_impl< void volatile > { static const bool value = (true); };
template<> struct is_pod_impl< void const volatile > { static const bool value = (true); };


}

template< typename T > struct is_POD : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };
template< typename T > struct is_pod : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 134 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
# 27 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4






# 1 "/usr/include/boost/mpl/always.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/always.hpp" 3 4
namespace boost { namespace mpl {

template< typename Value > struct always
{
    template<
          typename T
        , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na
        >
    struct apply
    {
        typedef Value type;
    };
};



}}
# 34 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_fwd.hpp" 1 3 4
# 31 "/usr/include/boost/mpl/apply_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct apply;

template<
      typename F
    >
struct apply0;

template<
      typename F, typename T1
    >
struct apply1;

template<
      typename F, typename T1, typename T2
    >
struct apply2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5;

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/apply_fwd.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_apply.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/has_apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/has_xxx.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

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






template< typename T > struct wrapped_type;

template< typename T > struct wrapped_type< type_wrapper<T> >
{
    typedef T type;
};







}}}
# 20 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/has_apply.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4

namespace boost { namespace mpl { namespace aux {

template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };







}}}
# 24 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/msvc_never_true.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 34 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F

    , typename has_apply_ = typename aux::has_apply<F>::type

    >
struct apply_wrap0

    : F::template apply< >
{
};

template< typename F >
struct apply_wrap0< F,true_ >
    : F::apply
{
};

template<
      typename F, typename T1

    >
struct apply_wrap1

    : F::template apply<T1>
{
};

template<
      typename F, typename T1, typename T2

    >
struct apply_wrap2

    : F::template apply< T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3

    >
struct apply_wrap3

    : F::template apply< T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4

    >
struct apply_wrap4

    : F::template apply< T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5

    >
struct apply_wrap5

    : F::template apply< T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/lambda.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/bind.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/bind_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/bind.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4






# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct bind;

template<
      typename F
    >
struct bind0;

template<
      typename F, typename T1
    >
struct bind1;

template<
      typename F, typename T1, typename T2
    >
struct bind2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5;

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/next.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/next.hpp" 3 4
# 1 "/usr/include/boost/mpl/next_prior.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/next_prior.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/common_name_wknd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/next_prior.hpp" 2 3 4



namespace boost { namespace mpl {




template<
      typename T = na
    >
struct next
{
    typedef typename T::next type;
   
};

template<
      typename T = na
    >
struct prior
{
    typedef typename T::prior type;
   
};

template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost/mpl/next.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/protect.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/protect.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename T = na
    , int not_le_ = 0
    >
struct protect : T
{



    typedef protect type;

};
# 48 "/usr/include/boost/mpl/protect.hpp" 3 4
template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };

namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }


}}
# 27 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 50 "/usr/include/boost/mpl/bind.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template<
      typename T, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg
{
    typedef T type;
};

template<
      typename T
    , typename Arg
    >
struct replace_unnamed_arg
{
    typedef Arg next;
    typedef T type;
};

template<
      typename Arg
    >
struct replace_unnamed_arg< arg< -1 >, Arg >
{
    typedef typename Arg::next next;
    typedef Arg type;
};

template<
      int N, typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
{
    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
{
    typedef bind< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}

template<
      typename F
    >
struct bind0
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

     public:
        typedef typename apply_wrap0<
              f_
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind0<F>, U1, U2, U3, U4, U5
    >
{
    typedef bind0<F> f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }

template<
      typename F
    >
struct bind< F,na,na,na,na,na >
    : bind0<F>
{
};

template<
      typename F, typename T1
    >
struct bind1
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

     public:
        typedef typename apply_wrap1<
              f_
            , typename t1::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename U1, typename U2, typename U3
    , typename U4, typename U5
    >
struct resolve_bind_arg<
      bind1< F,T1 >, U1, U2, U3, U4, U5
    >
{
    typedef bind1< F,T1 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }

template<
      typename F, typename T1
    >
struct bind< F,T1,na,na,na,na >
    : bind1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct bind2
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

     public:
        typedef typename apply_wrap2<
              f_
            , typename t1::type, typename t2::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename U1, typename U2
    , typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
    >
{
    typedef bind2< F,T1,T2 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }

template<
      typename F, typename T1, typename T2
    >
struct bind< F,T1,T2,na,na,na >
    : bind2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

     public:
        typedef typename apply_wrap3<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename U1
    , typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
    >
{
    typedef bind3< F,T1,T2,T3 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind< F,T1,T2,T3,na,na >
    : bind3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

     public:
        typedef typename apply_wrap4<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
    >
{
    typedef bind4< F,T1,T2,T3,T4 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind< F,T1,T2,T3,T4,na >
    : bind4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

        typedef aux::replace_unnamed_arg< T5,n5 > r5;
        typedef typename r5::type a5;
        typedef typename r5::next n6;
        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;

     public:
        typedef typename apply_wrap5<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type, typename t5::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
    >
{
    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind
    : bind5< F,T1,T2,T3,T4,T5 >
{
};


template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
struct quote3;

template< typename T1, typename T2, typename T3 > struct if_;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< if_,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename if_<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

template<
      template< typename T1, typename T2, typename T3 > class F, typename Tag
    >
struct quote3;

template< typename T1, typename T2, typename T3 > struct eval_if;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< eval_if,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename eval_if<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 51 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/lambda.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/quote.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/quote.hpp" 3 4
# 1 "/usr/include/boost/mpl/void.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/void.hpp" 3 4
namespace mpl_ {





struct void_ { typedef void_ type; };

}

namespace boost { namespace mpl {

template< typename T >
struct is_void_
    : false_
{



};

template<>
struct is_void_<void_>
    : true_
{



};

template< typename T >
struct is_not_void_
    : true_
{



};

template<>
struct is_not_void_<void_>
    : false_
{



};

template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }

}}
# 23 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/has_type.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_type.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 24 "/usr/include/boost/mpl/quote.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/bcc.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/quote.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 3 4
namespace boost { namespace mpl {

template< typename T, bool has_type_ >
struct quote_impl
{
    typedef typename T::type type;
};

template< typename T >
struct quote_impl< T,false >
{
    typedef T type;
};

template<
      template< typename P1 > class F
    , typename Tag = void_
    >
struct quote1
{
    template< typename U1 > struct apply

        : quote_impl<
              F<U1>
            , aux::has_type< F<U1> >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2 > class F
    , typename Tag = void_
    >
struct quote2
{
    template< typename U1, typename U2 > struct apply

        : quote_impl<
              F< U1,U2 >
            , aux::has_type< F< U1,U2 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename Tag = void_
    >
struct quote3
{
    template< typename U1, typename U2, typename U3 > struct apply

        : quote_impl<
              F< U1,U2,U3 >
            , aux::has_type< F< U1,U2,U3 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename Tag = void_
    >
struct quote4
{
    template<
          typename U1, typename U2, typename U3, typename U4
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4 >
            , aux::has_type< F< U1,U2,U3,U4 > >::value
            >

    {
    };
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename Tag = void_
    >
struct quote5
{
    template<
          typename U1, typename U2, typename U3, typename U4
        , typename U5
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4,U5 >
            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
            >

    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
# 43 "/usr/include/boost/mpl/aux_/template_arity.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< int N > struct arity_tag
{
    typedef char (&type)[N + 1];
};

template<
      int C1, int C2, int C3, int C4, int C5, int C6
    >
struct max_arity
{
    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) );



};

arity_tag<0>::type arity_helper(...);

template<
      template< typename P1 > class F
    , typename T1
    >
typename arity_tag<1>::type
arity_helper(type_wrapper< F<T1> >, arity_tag<1>);

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    >
typename arity_tag<2>::type
arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    >
typename arity_tag<3>::type
arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    >
typename arity_tag<4>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    >
typename arity_tag<5>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5, typename P6
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename T6
    >
typename arity_tag<6>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
template< typename F, int N >
struct template_arity_impl
{
    static const int value = sizeof(arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1;


};

template< typename F >
struct template_arity
{
    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value );




    typedef mpl::int_<value> type;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/aux_/template_arity.hpp" 2 3 4
# 30 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template<
      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
    , bool C5 = false
    >
struct lambda_or
    : true_
{
};

template<>
struct lambda_or< false,false,false,false,false >
    : false_
{
};

}

template<
      typename T
    , typename Tag
    , typename Arity
    >
struct lambda
{
    typedef false_ is_le;
    typedef T result_;
    typedef T type;
};

template<
      typename T
    >
struct is_lambda_expression
    : lambda<T>::is_le
{
};

template< int N, typename Tag >
struct lambda< arg<N>,Tag, int_< -1 > >
{
    typedef true_ is_le;
    typedef mpl::arg<N> result_;
    typedef mpl::protect<result_> type;
};

template<
      typename F
    , typename Tag
    >
struct lambda<
          bind0<F>
        , Tag
        , int_<1>
        >
{
    typedef false_ is_le;
    typedef bind0<
          F
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1
{
    typedef F<
          typename L1::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1< true_,Tag,F,L1 >
{
    typedef bind1<
          quote1< F,Tag >
        , typename L1::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1 > class F
    , typename T1
    , typename Tag
    >
struct lambda<
          F<T1>
        , Tag
        , int_<1>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef typename l1::is_le is_le1;
    typedef typename aux::lambda_or<
          is_le1::value
        >::type is_le;

    typedef aux::le_result1<
          is_le, Tag, F, l1
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1
    , typename Tag
    >
struct lambda<
          bind1< F,T1 >
        , Tag
        , int_<2>
        >
{
    typedef false_ is_le;
    typedef bind1<
          F
        , T1
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2
{
    typedef F<
          typename L1::type, typename L2::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2< true_,Tag,F,L1,L2 >
{
    typedef bind2<
          quote2< F,Tag >
        , typename L1::result_, typename L2::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    , typename Tag
    >
struct lambda<
          F< T1,T2 >
        , Tag
        , int_<2>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value
        >::type is_le;

    typedef aux::le_result2<
          is_le, Tag, F, l1, l2
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2
    , typename Tag
    >
struct lambda<
          bind2< F,T1,T2 >
        , Tag
        , int_<3>
        >
{
    typedef false_ is_le;
    typedef bind2<
          F
        , T1, T2
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3< true_,Tag,F,L1,L2,L3 >
{
    typedef bind3<
          quote3< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3 >
        , Tag
        , int_<3>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value
        >::type is_le;

    typedef aux::le_result3<
          is_le, Tag, F, l1, l2, l3
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          bind3< F,T1,T2,T3 >
        , Tag
        , int_<4>
        >
{
    typedef false_ is_le;
    typedef bind3<
          F
        , T1, T2, T3
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
{
    typedef bind4<
          quote4< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4 >
        , Tag
        , int_<4>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        >::type is_le;

    typedef aux::le_result4<
          is_le, Tag, F, l1, l2, l3, l4
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          bind4< F,T1,T2,T3,T4 >
        , Tag
        , int_<5>
        >
{
    typedef false_ is_le;
    typedef bind4<
          F
        , T1, T2, T3, T4
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
{
    typedef bind5<
          quote5< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_, typename L5::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4,T5 >
        , Tag
        , int_<5>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;
    typedef lambda< T5,Tag > l5;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;
    typedef typename l5::is_le is_le5;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        , is_le5::value
        >::type is_le;

    typedef aux::le_result5<
          is_le, Tag, F, l1, l2, l3, l4, l5
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind5< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind5<
          F
        , T1, T2, T3, T4, T5
        > result_;

    typedef result_ type;
};


template< typename T, typename Tag >
struct lambda< mpl::protect<T>,Tag, int_<1> >
{
    typedef false_ is_le;
    typedef mpl::protect<T> result_;
    typedef result_ type;
};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind< F,T1,T2,T3,T4,T5 > result_;
    typedef result_ type;
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    , typename Arity
    >
struct lambda<
          lambda< F,Tag1,Arity >
        , Tag2
        , int_<3>
        >
{
    typedef lambda< F,Tag2 > l1;
    typedef lambda< Tag1,Tag2 > l2;
    typedef typename l1::is_le is_le;
    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F
    >
struct apply0

    : apply_wrap0<
          typename lambda<F>::type

        >
{
   




};

template<
      typename F
    >
struct apply< F,na,na,na,na,na >
    : apply0<F>
{
};

template<
      typename F, typename T1
    >
struct apply1

    : apply_wrap1<
          typename lambda<F>::type
        , T1
        >
{
   




};

template<
      typename F, typename T1
    >
struct apply< F,T1,na,na,na,na >
    : apply1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct apply2

    : apply_wrap2<
          typename lambda<F>::type
        , T1, T2
        >
{
   




};

template<
      typename F, typename T1, typename T2
    >
struct apply< F,T1,T2,na,na,na >
    : apply2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3

    : apply_wrap3<
          typename lambda<F>::type
        , T1, T2, T3
        >
{
   




};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply< F,T1,T2,T3,na,na >
    : apply3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4

    : apply_wrap4<
          typename lambda<F>::type
        , T1, T2, T3, T4
        >
{
   




};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply< F,T1,T2,T3,T4,na >
    : apply4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5

    : apply_wrap5<
          typename lambda<F>::type
        , T1, T2, T3, T4, T5
        >
{
   




};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply
    : apply5< F,T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 35 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 38 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4

namespace boost
{


  template <class I, class V, class TC, class R, class D> class iterator_facade;

  namespace detail
  {



    struct always_bool2
    {
        template <class T, class U>
        struct apply
        {
            typedef bool type;
        };
    };




    template <
        class Facade1
      , class Facade2
      , class Return
    >
    struct enable_if_interoperable
# 80 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
      : ::boost::iterators::enable_if<
           mpl::or_<
               is_convertible<Facade1, Facade2>
             , is_convertible<Facade2, Facade1>
           >
         , Return
        >
    {};






    template <
        class ValueParam
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    struct iterator_facade_types
    {
        typedef typename facade_iterator_category<
            CategoryOrTraversal, ValueParam, Reference
        >::type iterator_category;

        typedef typename remove_const<ValueParam>::type value_type;

        typedef typename mpl::eval_if<
            boost::detail::iterator_writability_disabled<ValueParam,Reference>
          , add_pointer<const value_type>
          , add_pointer<value_type>
        >::type pointer;
# 130 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    };







    template <class Iterator>
    class postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
     public:
        explicit postfix_increment_proxy(Iterator const& x)
          : stored_value(*x)
        {}





        value_type&
        operator*() const
        {
            return this->stored_value;
        }
     private:
        mutable value_type stored_value;
    };





    template <class Iterator>
    class writable_postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;
     public:
        explicit writable_postfix_increment_proxy(Iterator const& x)
          : stored_value(*x)
          , stored_iterator(x)
        {}





        writable_postfix_increment_proxy const&
        operator*() const
        {
            return *this;
        }


        operator value_type&() const
        {
            return stored_value;
        }


        template <class T>
        T const& operator=(T const& x) const
        {
            *this->stored_iterator = x;
            return x;
        }


        template <class T>
        T& operator=(T& x) const
        {
            *this->stored_iterator = x;
            return x;
        }


        operator Iterator const&() const
        {
            return stored_iterator;
        }

     private:
        mutable value_type stored_value;
        Iterator stored_iterator;
    };
# 244 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
            typename remove_reference<Reference>::type
            const volatile*
          , Value const volatile*
        >
    {};
# 269 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
    struct postfix_increment_result
      : mpl::eval_if<
            mpl::and_<

                is_convertible<Reference,Value const&>



              , mpl::not_<
                    is_convertible<
                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
                      , forward_traversal_tag
                    >
                >
            >
          , mpl::if_<
                is_non_proxy_reference<Reference,Value>
              , postfix_increment_proxy<Iterator>
              , writable_postfix_increment_proxy<Iterator>
            >
          , mpl::identity<Iterator>
        >
    {};





    template <class T>
    struct operator_arrow_proxy
    {
        operator_arrow_proxy(T const* px) : m_value(*px) {}
        T* operator->() const { return &m_value; }


        operator T*() const { return &m_value; }
        mutable T m_value;
    };




    template <class ValueType, class Reference, class Pointer>
    struct operator_arrow_result
    {



        typedef typename mpl::if_<
            is_reference<Reference>
          , Pointer
          , operator_arrow_proxy<ValueType>
        >::type type;

        static type make(Reference x)
        {
            return implicit_cast<type>(&x);
        }
    };
# 342 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Iterator>
    class operator_brackets_proxy
    {


        typedef typename Iterator::reference reference;
        typedef typename Iterator::value_type value_type;

     public:
        operator_brackets_proxy(Iterator const& iter)
          : m_iter(iter)
        {}

        operator reference() const
        {
            return *m_iter;
        }

        operator_brackets_proxy& operator=(value_type const& val)
        {
            *m_iter = val;
            return *this;
        }

     private:
        Iterator m_iter;
    };



    template <class ValueType, class Reference>
    struct use_operator_brackets_proxy
      : mpl::not_<
            mpl::and_<


                boost::is_POD<ValueType>
              , iterator_writability_disabled<ValueType,Reference>
            >
        >
    {};

    template <class Iterator, class Value, class Reference>
    struct operator_brackets_result
    {
        typedef typename mpl::if_<
            use_operator_brackets_proxy<Value,Reference>
          , operator_brackets_proxy<Iterator>
          , Value
        >::type type;
    };

    template <class Iterator>
    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
    {
        return operator_brackets_proxy<Iterator>(iter);
    }

    template <class Iterator>
    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
    {
      return *iter;
    }

    struct choose_difference_type
    {
        template <class I1, class I2>
        struct apply
          :
# 420 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >

        {};

    };
  }
# 471 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  class iterator_core_access
  {






      template <class I, class V, class TC, class R, class D> friend class iterator_facade;




      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);

      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);


      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)

      ;

      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)




      ;

      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)




      ;



      template <class Facade>
      static typename Facade::reference dereference(Facade const& f)
      {
          return f.dereference();
      }

      template <class Facade>
      static void increment(Facade& f)
      {
          f.increment();
      }

      template <class Facade>
      static void decrement(Facade& f)
      {
          f.decrement();
      }

      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
      {
          return f1.equal(f2);
      }

      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
      {
          return f2.equal(f1);
      }

      template <class Facade>
      static void advance(Facade& f, typename Facade::difference_type n)
      {
          f.advance(n);
      }

      template <class Facade1, class Facade2>
      static typename Facade1::difference_type distance_from(
          Facade1 const& f1, Facade2 const& f2, mpl::true_)
      {
          return -f1.distance_to(f2);
      }

      template <class Facade1, class Facade2>
      static typename Facade2::difference_type distance_from(
          Facade1 const& f1, Facade2 const& f2, mpl::false_)
      {
          return f2.distance_to(f1);
      }




      template <class I, class V, class TC, class R, class D>
      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
      {
          return *static_cast<I*>(&facade);
      }

      template <class I, class V, class TC, class R, class D>
      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
      {
          return *static_cast<I const*>(&facade);
      }

   private:

      iterator_core_access();
  };





  template <
      class Derived
    , class Value
    , class CategoryOrTraversal
    , class Reference = Value&
    , class Difference = std::ptrdiff_t
  >
  class iterator_facade






  {
   private:



      Derived& derived()
      {
          return *static_cast<Derived*>(this);
      }

      Derived const& derived() const
      {
          return *static_cast<Derived const*>(this);
      }

      typedef boost::detail::iterator_facade_types<
         Value, CategoryOrTraversal, Reference, Difference
      > associated_types;

   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 associated_types::pointer pointer;
      typedef typename associated_types::iterator_category iterator_category;

      reference operator*() const
      {
          return iterator_core_access::dereference(this->derived());
      }

      typename boost::detail::operator_arrow_result<
          value_type
        , reference
        , pointer
      >::type
      operator->() const
      {
          return boost::detail::operator_arrow_result<
              value_type
            , reference
            , pointer
          >::make(*this->derived());
      }

      typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
      operator[](difference_type n) const
      {
          typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;

          return boost::detail::make_operator_brackets_result<Derived>(
              this->derived() + n
            , use_proxy()
          );
      }

      Derived& operator++()
      {
          iterator_core_access::increment(this->derived());
          return this->derived();
      }
# 679 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
      Derived& operator--()
      {
          iterator_core_access::decrement(this->derived());
          return this->derived();
      }

      Derived operator--(int)
      {
          Derived tmp(this->derived());
          --*this;
          return tmp;
      }

      Derived& operator+=(difference_type n)
      {
          iterator_core_access::advance(this->derived(), n);
          return this->derived();
      }

      Derived& operator-=(difference_type n)
      {
          iterator_core_access::advance(this->derived(), -n);
          return this->derived();
      }

      Derived operator-(difference_type x) const
      {
          Derived result(this->derived());
          return result -= x;
      }
# 721 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  };


  template <class I, class V, class TC, class R, class D>
  inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
  operator++(
      iterator_facade<I,V,TC,R,D>& i
    , int
  )
  {
      typename boost::detail::postfix_increment_result<I,V,R,TC>::type
          tmp(*static_cast<I*>(&i));

      ++i;

      return tmp;
  }
# 836 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_836; return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_837; return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }

  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_839; return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_840; return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_841; return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_842; return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }



  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_851; return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
# 862 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }




template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }






}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 877 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 2



# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/aterm_conversion.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/aterm_conversion.h"
namespace {





  inline
  ATerm void2term(void* t)
  { return reinterpret_cast<ATerm>(t); }




  inline
  ATerm void2term(const void* t)
  { return reinterpret_cast<ATerm>(const_cast<void*>(t)); }




  inline
  void* term2void(ATerm t)
  { return reinterpret_cast<void*>(t); }





  inline
  ATermList void2list(void* t)
  { return reinterpret_cast<ATermList>(t); }




  inline
  ATermList void2list(const void* t)
  { return reinterpret_cast<ATermList>(const_cast<void*>(t)); }




  inline
  void* list2void(ATermList l)
  { return reinterpret_cast<void*>(l); }





  inline
  ATermAppl void2appl(void* t)
  { return reinterpret_cast<ATermAppl>(t); }




  inline
  ATermAppl void2appl(const void* t)
  { return reinterpret_cast<ATermAppl>(const_cast<void*>(t)); }




  inline
  void* appl2void(ATermAppl l)
  { return reinterpret_cast<void*>(l); }





  inline
  ATermReal void2real(void* t)
  { return reinterpret_cast<ATermReal>(t); }




  inline
  ATermReal void2real(const void* t)
  { return reinterpret_cast<ATermReal>(const_cast<void*>(t)); }




  inline
  void* real2void(ATermReal l)
  { return reinterpret_cast<void*>(l); }





  inline
  ATermBlob void2blob(void* t)
  { return reinterpret_cast<ATermBlob>(t); }




  inline
  ATermBlob void2blob(const void* t)
  { return reinterpret_cast<ATermBlob>(const_cast<void*>(t)); }




  inline
  void* blob2void(ATermBlob l)
  { return reinterpret_cast<void*>(l); }





  inline
  ATermInt void2int(void* t)
  { return reinterpret_cast<ATermInt>(t); }




  inline
  ATermInt void2int(const void* t)
  { return reinterpret_cast<ATermInt>(const_cast<void*>(t)); }




  inline
  void* int2void(ATermInt l)
  { return reinterpret_cast<void*>(l); }





  inline
  ATermPlaceholder void2place_holder(void* t)
  { return reinterpret_cast<ATermPlaceholder>(t); }

}
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list_iterator.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list_iterator.h"
namespace atermpp {



  template <class T>
  struct term_list_iterator_traits
  {
    typedef ATerm value_type;
  };



template <typename Value>
class term_list_iterator: public boost::iterator_facade<
        term_list_iterator<Value>,
        const Value,
        boost::forward_traversal_tag,
        const Value
    >
{
 public:

    term_list_iterator()
      : m_list(ATempty)
    {}



    term_list_iterator(ATermList l)
      : m_list(l)
    {}


    ATermList list() const
    {
      return m_list;
    }

 private:
    friend class boost::iterator_core_access;




    bool equal(term_list_iterator const& other) const
    { return this->m_list == other.m_list; }



    const Value dereference() const
    {
      return Value(typename term_list_iterator_traits<Value>::value_type((((ATermList)m_list)->aterm.head)));
    }


    void increment()
    { m_list = (((ATermList)m_list)->aterm.tail); }

    ATermList m_list;
};

}
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 2


namespace {
# 36 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h"
  inline ATermList aterm_get_next(ATermList l)
  {
    return (((ATermList)l)->aterm.tail);
  }




  inline ATerm aterm_get_first(ATermList l)
  {
    return (((ATermList)l)->aterm.head);
  }




  inline
  int aterm_get_length(ATermList l)
  {
    return ATgetLength(l);
  }
}


namespace atermpp {


  template <typename Term>
  class term_list: public aterm_base
  {
    protected:


      ATermList list() const
      { return reinterpret_cast<ATermList>(m_term); }



      ATermList list()
      { return reinterpret_cast<ATermList>(m_term); }

    public:

      typedef Term value_type;


      typedef Term* pointer;


      typedef Term& reference;


      typedef const Term const_reference;


      typedef size_t size_type;


      typedef ptrdiff_t difference_type;


      typedef term_list_iterator<Term> iterator;


      typedef term_list_iterator<Term> const_iterator;


      term_list()
        : aterm_base((ATempty))
      {}



      term_list(ATermList l)
        : aterm_base(l)
      {
      }



      template <typename SpecificTerm>
      term_list(const term_list<SpecificTerm>& t);



      term_list(aterm t)
        : aterm_base(t)
      {
        ((type() == 4L) ? static_cast<void> (0) : __assert_fail ("type() == 4L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h", 124, __PRETTY_FUNCTION__));
      }




      template <class Iter>
      term_list(Iter first, Iter last, typename boost::enable_if<
                typename boost::is_convertible< typename boost::iterator_traversal< Iter >::type,
                                        boost::random_access_traversal_tag >::type >::type* = 0)
        : aterm_base((ATempty))
      {
        while (first != last)
          m_term = void2term(list2void(ATinsert(list(), aterm(*(--last)))));
      }




      template <class Iter>
      term_list(Iter first, Iter last, typename boost::disable_if<
                typename boost::is_convertible< typename boost::iterator_traversal< Iter >::type,
                                        boost::random_access_traversal_tag >::type >::type* = 0)
        : aterm_base((ATempty))
      {
        while (first != last)
          m_term = void2term(list2void(ATinsert(list(), aterm(*(first++)))));
        m_term = void2term(list2void(ATreverse(list())));
      }




      term_list<Term>& operator=(aterm_base t)
      {
        ((t.type() == 4L) ? static_cast<void> (0) : __assert_fail ("t.type() == 4L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h", 159, __PRETTY_FUNCTION__));
        m_term = aterm_traits<aterm_base>::term(t);
        return *this;
      }



      term_list<Term>& operator=(ATermList t)
      {
        m_term = reinterpret_cast<ATerm>(t);
        return *this;
      }



      const_iterator begin() const
      { return const_iterator(list()); }



      const_iterator end() const
      { return const_iterator((ATempty)); }



      size_type size() const
      { return aterm_get_length(list()); }



      size_type max_size() const
      { return ((unsigned long)(((std::numeric_limits<unsigned long>::max)()) >> 34)); }



      bool empty() const
      { return ((ATbool)(((ATermList)list())->aterm.head == __null && ((ATermList)list())->aterm.tail == __null)) == ATtrue; }



      Term front() const
      { return Term(void2appl(term2void(aterm_get_first(list())))); }




      const_iterator previous(const_iterator pos) const
      {
        const_iterator prev = end();
        for (const_iterator i = begin(); i != end(); ++i)
        {
          if (i == pos)
            return prev;
          prev = i;
        }
        return end();
      }



      operator ATermList() const
      { return void2list(m_term); }







      template <typename Substitution>
      term_list<Term> substitute(Substitution f) const
      {
        return term_list<Term>(f(*this));
      }
  };


  typedef term_list<aterm> aterm_list;




  template <typename Term>
  inline
  Term front(term_list<Term> l)
  {
    return *l.begin();
  }





  template <typename Term>
  inline
  term_list<Term> push_front(term_list<Term> l, Term elem)
  {
    return term_list<Term>(ATinsert(l, aterm_traits<Term>::term(elem)));
  }







  template <typename Term>
  inline
  term_list<Term> push_back(term_list<Term> l, Term elem)
  {
    return term_list<Term>(ATappend(l, aterm_traits<Term>::term(elem)));
  }




  template <typename Term>
  inline
  term_list<Term> pop_front(term_list<Term> l)
  {
    return term_list<Term>(aterm_get_next(l));
  }




  template <typename Term>
  inline
  term_list<Term> reverse(term_list<Term> l)
  {
    return term_list<Term>(ATreverse(l));
  }





  template <typename Term, typename Function>
  inline
  aterm_list apply(term_list<Term> l, const Function f)
  {
    aterm_list result;
    for (typename term_list<Term>::iterator i = l.begin(); i != l.end(); ++i)
    {
      result = push_front(result, aterm(f(*i)));
    }
    return reverse(result);
  }





  template <typename Term>
  inline
  term_list<Term> operator+(term_list<Term> l, term_list<Term> m)
  { return term_list<Term>(ATconcat(l, m)); }





  template <typename Term>
  inline
  term_list<Term> operator+(term_list<Term> l, Term t)
  { ((t.type() != 0L) ? static_cast<void> (0) : __assert_fail ("t.type() != 0L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h", 324, __PRETTY_FUNCTION__));
    return term_list<Term>(ATappend(l, aterm_traits<Term>::term(t)));
  }





  template <typename Term>
  inline
  term_list<Term> operator+(Term t, term_list<Term> l)
  { return push_front(l, t); }


  template <typename Term>
  struct aterm_traits<term_list<Term> >
  {
    typedef ATermList aterm_type;
    static void protect(term_list<Term> t) { t.protect(); }
    static void unprotect(term_list<Term> t) { t.unprotect(); }
    static void mark(term_list<Term> t) { t.mark(); }
    static ATerm term(term_list<Term> t) { return t.term(); }
    static ATerm* ptr(term_list<Term>& t) { return &t.term(); }
  };






  template <typename Term>
  bool operator==(const term_list<Term>& x, const term_list<Term>& y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_list<Term> >::term(x)) == (ATerm)(aterm_traits<term_list<Term> >::term(y)))) == ATtrue;
  }





  template <typename Term>
  bool operator==(const term_list<Term>& x, ATermList y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_list<Term> >::term(x)) == (ATerm)(y))) == ATtrue;
  }





  template <typename Term>
  bool operator==(ATermList x, const term_list<Term>& y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(aterm_traits<term_list<Term> >::term(y)))) == ATtrue;
  }





  template <typename Term>
  bool operator!=(const term_list<Term>& x, const term_list<Term>& y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_list<Term> >::term(x)) == (ATerm)(aterm_traits<term_list<Term> >::term(y)))) == ATfalse;
  }





  template <typename Term>
  bool operator!=(const term_list<Term>& x, ATermList y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_list<Term> >::term(x)) == (ATerm)(y))) == ATfalse;
  }





  template <typename Term>
  bool operator!=(ATermList x, const term_list<Term>& y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(aterm_traits<term_list<Term> >::term(y)))) == ATfalse;
  }


  template <typename Term>
  template <typename SpecificTerm>
  term_list<Term>::term_list(const term_list<SpecificTerm>& t)
    : aterm_base(t)
  {}

}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/function_symbol.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/function_symbol.h"
namespace atermpp
{

  class function_symbol
  {
    protected:

      AFun m_function;

    public:




      function_symbol(const std::string& name, int arity, bool quoted = false)
        : m_function(ATmakeAFun(const_cast<char*>(name.c_str()), arity, quoted ? ATtrue : ATfalse))
      {}



      function_symbol(AFun function):
        m_function(function)
      {}




      void protect()
      {
        ATprotectAFun(m_function);
      }


      void unprotect()
      {
        ATunprotectAFun(m_function);
      }



      std::string name() const
      {
        return std::string((at_lookup_table[(m_function)]->name));
      }



      unsigned int arity() const
      {
        return ((unsigned int)((unsigned long)((at_lookup_table_alias[(m_function)]->header) >> 34)));
      }



      bool is_quoted() const
      {
        return (((at_lookup_table_alias[(m_function)]->header) & (1<<3)) ? ATtrue : ATfalse);
      }



      operator AFun() const
      { return m_function; }

      friend bool operator!=(const function_symbol& x, const function_symbol& y);
  };







  inline
  bool operator==(const function_symbol& x, const function_symbol& y)
  {

    return AFun(x) == AFun(y);
  }







  inline
  bool operator!=(const function_symbol& x, const function_symbol& y)
  { return !(x == y); }

}
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_iterator.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_iterator.h"
namespace atermpp {


template <typename Value>
class term_appl_iterator: public boost::iterator_facade<
        term_appl_iterator<Value>,
        const Value,
        boost::forward_traversal_tag,
        const Value
    >
{
 public:

    term_appl_iterator()
    {}



    term_appl_iterator(ATerm* t)
      : m_term(t)
    {}

 private:
    friend class boost::iterator_core_access;




    bool equal(term_appl_iterator const& other) const
    { return this->m_term == other.m_term; }



    const Value dereference() const
    {
      return Value(*m_term);
    }


    void increment()
    { m_term++; }


    void decrement()
    { m_term--; }

    ATerm* m_term;
};

}
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 2

namespace atermpp
{

  template <typename Term>
  class term_appl: public aterm_base
  {
    friend class aterm_string;

    private:




      Term operator[](unsigned int i) const
      {
        return Term();
      }

    protected:


      ATermAppl appl() const
      {
        return reinterpret_cast<ATermAppl>(m_term);
      }

    public:

      typedef Term value_type;


      typedef Term* pointer;


      typedef Term& reference;


      typedef const Term const_reference;


      typedef size_t size_type;


      typedef ptrdiff_t difference_type;


      typedef term_appl_iterator<Term> iterator;


      typedef term_appl_iterator<Term> const_iterator;


      term_appl()
      {}



      term_appl(ATerm term)
        : aterm_base(term)
      {
        ((type() == 1L) ? static_cast<void> (0) : __assert_fail ("type() == 1L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h", 82, __PRETTY_FUNCTION__));
      }



      term_appl(ATermAppl term)
        : aterm_base(term)
      {}




      term_appl(function_symbol sym, term_list<Term> args)
        : aterm_base(ATmakeApplList(sym, args))
      {}



      term_appl(aterm t)
        : aterm_base(t)
      {}





      template <typename Iter>
      term_appl(function_symbol sym, Iter first, Iter last)
      {
        std::vector<ATerm> arguments;
        for (Iter i = first; i != last; ++i)
        {
          arguments.push_back(aterm_traits<typename std::iterator_traits<Iter>::value_type>::term(*i));
        }
        m_term = reinterpret_cast< ATerm >(ATmakeApplArray(sym, &(arguments.front())));
      }



      term_appl(function_symbol sym)
        : aterm_base(ATmakeAppl0(sym))
      {
      }

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h"
# 1 "/usr/include/boost/preprocessor/repetition.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/repetition.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/deduce_r.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/repetition/deduce_r.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/repetition/deduce_r.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/for.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 42 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 1 3 4
# 43 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 17 "/usr/include/boost/preprocessor/repetition/deduce_r.hpp" 2 3 4
# 16 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/deduce_z.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/repetition/deduce_z.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/repetition/deduce_z.hpp" 2 3 4
# 17 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/enum.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/repetition/enum.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/facilities/intercept.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_params_with_defaults.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_shifted.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/repetition/enum_shifted.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 23 "/usr/include/boost/preprocessor/repetition/enum_shifted.hpp" 2 3 4
# 23 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_shifted_binary_params.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_shifted_params.hpp" 1 3 4
# 25 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_trailing.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/repetition/enum_trailing.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/repetition/enum_trailing.hpp" 2 3 4
# 26 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_trailing_binary_params.hpp" 1 3 4
# 27 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1 3 4
# 28 "/usr/include/boost/preprocessor/repetition.hpp" 2 3 4
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 2


# 1 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/array/elem.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/array/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/array/data.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/array/size.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/slot/slot.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/slot/slot.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/def.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/slot/slot.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/iteration/iterate.hpp" 2 3 4
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 2
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h"
# 1 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1 3 4
# 12 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/slot/detail/shared.hpp" 1 3 4
# 13 "/usr/include/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 52 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 3 4
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1 3 4
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 3 4
    term_appl(function_symbol sym, aterm a0)
      : aterm_base(ATmakeAppl1(sym, a0))
    {
    }
# 53 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1 3 4
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 3 4
    term_appl(function_symbol sym, aterm a0 , aterm a1)
      : aterm_base(ATmakeAppl2(sym, a0 , a1))
    {
    }
# 58 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1 3 4
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 3 4
    term_appl(function_symbol sym, aterm a0 , aterm a1 , aterm a2)
      : aterm_base(ATmakeAppl3(sym, a0 , a1 , a2))
    {
    }
# 63 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1 3 4
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 3 4
    term_appl(function_symbol sym, aterm a0 , aterm a1 , aterm a2 , aterm a3)
      : aterm_base(ATmakeAppl4(sym, a0 , a1 , a2 , a3))
    {
    }
# 68 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1 3 4
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 3 4
    term_appl(function_symbol sym, aterm a0 , aterm a1 , aterm a2 , aterm a3 , aterm a4)
      : aterm_base(ATmakeAppl5(sym, a0 , a1 , a2 , a3 , a4))
    {
    }
# 73 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4




# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 1 3 4
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 3 4
    term_appl(function_symbol sym, aterm a0 , aterm a1 , aterm a2 , aterm a3 , aterm a4 , aterm a5)
      : aterm_base(ATmakeAppl6(sym, a0 , a1 , a2 , a3 , a4 , a5))
    {
    }
# 78 "/usr/include/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2 3 4
# 30 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl_constructor.h" 2
# 127 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 2



      operator ATermAppl() const
      {
        return reinterpret_cast<ATermAppl>(m_term);
      }




      term_appl<Term>& operator=(aterm_base t)
      {
        ((t.type() == 1L) ? static_cast<void> (0) : __assert_fail ("t.type() == 1L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h", 140, __PRETTY_FUNCTION__));
        m_term = aterm_traits<aterm_base>::term(t);
        return *this;
      }




      term_appl<Term>& operator=(ATermAppl t)
      {
        ((t==__null || ((unsigned int)((((t)->header) & (((1 << 3)-1) << 4)) >> 4)) != 0L) ? static_cast<void> (0) : __assert_fail ("t==__null || ((unsigned int)((((t)->header) & (((1 << 3)-1) << 4)) >> 4)) != 0L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h", 150, __PRETTY_FUNCTION__));
        m_term = reinterpret_cast<ATerm>(t);
        return *this;
      }



      size_type size() const
      { return ((unsigned int)((unsigned long)((at_lookup_table_alias[(((AFun)(((appl())->header) >> 34)))]->header) >> 34))); }



      const_iterator begin() const
      {
        return const_iterator(((ATerm *)(m_term) + ((sizeof(struct __ATerm)/(sizeof(long)))+0)));
      }



      const_iterator end() const
      {
        return const_iterator(((ATerm *)(m_term) + ((sizeof(struct __ATerm)/(sizeof(long)))+0) + size()));
      }



      size_type max_size() const
      { return (std::numeric_limits<unsigned long>::max)(); }



      bool empty() const
      { return size() == 0; }



      function_symbol function() const
      {
        return function_symbol(((AFun)(((appl())->header) >> 34)));
      }



      bool is_quoted() const
      {
        return function().is_quoted();
      }




      Term operator()(unsigned int i) const
      {
        return Term((((ATermAppl)appl())->aterm.arg[i]));
      }






      term_appl<Term> set_argument(Term t, unsigned int i)
      {
        return ATsetArgument(appl(), t, i);
      }





      aterm argument(unsigned int i) const
      {
        return aterm((((ATermAppl)appl())->aterm.arg[i]));
      }




      term_list<Term> argument_list() const
      {
        return term_list<Term>(ATgetArguments(appl()));
      }
  };


  typedef term_appl<aterm> aterm_appl;


  template <typename Term>
  struct aterm_traits<term_appl<Term> >
  {
    typedef ATermAppl aterm_type;
    static void protect(term_appl<Term> t) { t.protect(); }
    static void unprotect(term_appl<Term> t) { t.unprotect(); }
    static void mark(term_appl<Term> t) { t.mark(); }
    static ATerm term(term_appl<Term> t) { return t.term(); }
    static ATerm* ptr(term_appl<Term>& t) { return &t.term(); }
  };

  template <typename T>
  struct aterm_appl_traits
  {

    typedef ATermAppl aterm_type;



    static void protect(aterm_appl t) { t.protect(); }



    static void unprotect(aterm_appl t) { t.unprotect(); }



    static void mark(aterm_appl t) { t.mark(); }




    static ATerm term(aterm_appl t) { return t.term(); }




    static ATerm* ptr(aterm_appl& t) { return &t.term(); }
  };

  template < typename T >
  struct select_traits_base< T, typename boost::enable_if<typename boost::is_base_of<term_appl<aterm>, T>::type>::type > {
    typedef aterm_appl_traits< T > base_type;
  };






  template <typename Term>
  bool operator==(const term_appl<Term>& x, const term_appl<Term>& y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_appl<Term> >::term(x)) == (ATerm)(aterm_traits<term_appl<Term> >::term(y)))) == ATtrue;
  }





  template <typename Term>
  bool operator==(const term_appl<Term>& x, ATermAppl y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_appl<Term> >::term(x)) == (ATerm)(y))) == ATtrue;
  }





  template <typename Term>
  bool operator==(ATermAppl x, const term_appl<Term>& y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(aterm_traits<term_appl<Term> >::term(y)))) == ATtrue;
  }





  template <typename Term>
  bool operator!=(const term_appl<Term>& x, const term_appl<Term>& y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_appl<Term> >::term(x)) == (ATerm)(aterm_traits<term_appl<Term> >::term(y)))) == ATfalse;
  }





  template <typename Term>
  bool operator!=(const term_appl<Term>& x, ATermAppl y)
  {
    return ((ATbool)((ATerm)(aterm_traits<term_appl<Term> >::term(x)) == (ATerm)(y))) == ATfalse;
  }





  template <typename Term>
  bool operator!=(ATermAppl x, const term_appl<Term>& y)
  {
    return ((ATbool)((ATerm)(x) == (ATerm)(aterm_traits<term_appl<Term> >::term(y)))) == ATfalse;
  }

}
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_access.h" 2


namespace atermpp
{



  inline
  aterm_appl arg1(ATermAppl t)
  {
    return aterm_appl(t)(0);
  }




  inline
  aterm_appl arg2(ATermAppl t)
  {
    return aterm_appl(t)(1);
  }




  inline
  aterm_appl arg3(ATermAppl t)
  {
    return aterm_appl(t)(2);
  }




  inline
  aterm_appl arg4(ATermAppl t)
  {
    return aterm_appl(t)(3);
  }




  inline
  ATermList list_arg1(ATermAppl t)
  {
    return aterm_list(aterm_appl(t)(0));
  }




  inline
  ATermList list_arg2(ATermAppl t)
  {
    return aterm_list(aterm_appl(t)(1));
  }




  inline
  ATermList list_arg3(ATermAppl t)
  {
    return aterm_list(aterm_appl(t)(2));
  }




  inline
  ATermList list_arg4(ATermAppl t)
  {
    return aterm_list(aterm_appl(t)(3));
  }

}
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/vector.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/vector.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/protaterm.h" 1



# 1 "/usr/include/c++/4.1.3/set" 1 3
# 63 "/usr/include/c++/4.1.3/set" 3
       
# 64 "/usr/include/c++/4.1.3/set" 3

# 1 "/usr/include/c++/4.1.3/bits/stl_tree.h" 1 3
# 72 "/usr/include/c++/4.1.3/bits/stl_tree.h" 3
namespace std
{
# 90 "/usr/include/c++/4.1.3/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;
    };

  _Rb_tree_node_base*
  _Rb_tree_increment(_Rb_tree_node_base* __x);

  const _Rb_tree_node_base*
  _Rb_tree_increment(const _Rb_tree_node_base* __x);

  _Rb_tree_node_base*
  _Rb_tree_decrement(_Rb_tree_node_base* __x);

  const _Rb_tree_node_base*
  _Rb_tree_decrement(const _Rb_tree_node_base* __x);

  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 &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) { }

      reference
      operator*() const
      { return static_cast<_Link_type>(_M_node)->_M_value_field; }

      pointer
      operator->() const
      { return &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_rotate_left(_Rb_tree_node_base* const __x,
                       _Rb_tree_node_base*& __root);

  void
  _Rb_tree_rotate_right(_Rb_tree_node_base* const __x,
                        _Rb_tree_node_base*& __root);

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

  _Rb_tree_node_base*
  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
          _Rb_tree_node_base& __header);


  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;
      typedef _Rb_tree_node<_Val> _Rb_tree_node;

    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* _Link_type;
      typedef const _Rb_tree_node* _Const_Link_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

      allocator_type
      get_allocator() const
      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }

    protected:
      _Rb_tree_node*
      _M_get_node()
      { return _M_impl._Node_allocator::allocate(1); }

      void
      _M_put_node(_Rb_tree_node* __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(&__tmp->_M_value_field, __x); }
 catch(...)
   {
     _M_put_node(__tmp);
     throw;
   }
 return __tmp;
      }

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

      void
      destroy_node(_Link_type __p)
      {
 get_allocator().destroy(&__p->_M_value_field);
 _M_put_node(__p);
      }

    protected:
      template<typename _Key_compare,
        bool _Is_pod_comparator = std::__is_pod<_Key_compare>::__value>
        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(const _Node_allocator& __a = _Node_allocator(),
   const _Key_compare& __comp = _Key_compare())
   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
     _M_node_count(0)
   {
     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;
   }
 };



      template<typename _Key_compare>
        struct _Rb_tree_impl<_Key_compare, true> : public _Node_allocator
 {
   _Key_compare _M_key_compare;
   _Rb_tree_node_base _M_header;
   size_type _M_node_count;

   _Rb_tree_impl(const _Node_allocator& __a = _Node_allocator(),
   const _Key_compare& __comp = _Key_compare())
   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
     _M_node_count(0)
   {
     this->_M_header._M_color = _S_red;
     this->_M_header._M_parent = 0;
     this->_M_header._M_left = &this->_M_header;
     this->_M_header._M_right = &this->_M_header;
   }
 };

      _Rb_tree_impl<_Compare> _M_impl;

    protected:
      _Base_ptr&
      _M_root()
      { return this->_M_impl._M_header._M_parent; }

      _Const_Base_ptr
      _M_root() const
      { return this->_M_impl._M_header._M_parent; }

      _Base_ptr&
      _M_leftmost()
      { return this->_M_impl._M_header._M_left; }

      _Const_Base_ptr
      _M_leftmost() const
      { return this->_M_impl._M_header._M_left; }

      _Base_ptr&
      _M_rightmost()
      { return this->_M_impl._M_header._M_right; }

      _Const_Base_ptr
      _M_rightmost() const
      { return this->_M_impl._M_header._M_right; }

      _Link_type
      _M_begin()
      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

      _Const_Link_type
      _M_begin() const
      {
 return static_cast<_Const_Link_type>
   (this->_M_impl._M_header._M_parent);
      }

      _Link_type
      _M_end()
      { return static_cast<_Link_type>(&this->_M_impl._M_header); }

      _Const_Link_type
      _M_end() const
      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }

      static const_reference
      _S_value(_Const_Link_type __x)
      { return __x->_M_value_field; }

      static const _Key&
      _S_key(_Const_Link_type __x)
      { return _KeyOfValue()(_S_value(__x)); }

      static _Link_type
      _S_left(_Base_ptr __x)
      { return static_cast<_Link_type>(__x->_M_left); }

      static _Const_Link_type
      _S_left(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x->_M_left); }

      static _Link_type
      _S_right(_Base_ptr __x)
      { return static_cast<_Link_type>(__x->_M_right); }

      static _Const_Link_type
      _S_right(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x->_M_right); }

      static const_reference
      _S_value(_Const_Base_ptr __x)
      { return static_cast<_Const_Link_type>(__x)->_M_value_field; }

      static const _Key&
      _S_key(_Const_Base_ptr __x)
      { return _KeyOfValue()(_S_value(__x)); }

      static _Base_ptr
      _S_minimum(_Base_ptr __x)
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Const_Base_ptr
      _S_minimum(_Const_Base_ptr __x)
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Base_ptr
      _S_maximum(_Base_ptr __x)
      { return _Rb_tree_node_base::_S_maximum(__x); }

      static _Const_Base_ptr
      _S_maximum(_Const_Base_ptr __x)
      { return _Rb_tree_node_base::_S_maximum(__x); }

    public:
      typedef _Rb_tree_iterator<value_type> iterator;
      typedef _Rb_tree_const_iterator<value_type> const_iterator;

      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    private:
      iterator
      _M_insert(_Base_ptr __x, _Base_ptr __y, const value_type& __v);

      const_iterator
      _M_insert(_Const_Base_ptr __x, _Const_Base_ptr __y,
  const value_type& __v);

      _Link_type
      _M_copy(_Const_Link_type __x, _Link_type __p);

      void
      _M_erase(_Link_type __x);

    public:

      _Rb_tree()
      { }

      _Rb_tree(const _Compare& __comp)
      : _M_impl(allocator_type(), __comp)
      { }

      _Rb_tree(const _Compare& __comp, const allocator_type& __a)
      : _M_impl(__a, __comp)
      { }

      _Rb_tree(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
      : _M_impl(__x.get_allocator(), __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;
   }
      }

      ~_Rb_tree()
      { _M_erase(_M_begin()); }

      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
      operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __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 size_type(-1); }

      void
      swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t);


      pair<iterator,bool>
      insert_unique(const value_type& __x);

      iterator
      insert_equal(const value_type& __x);

      iterator
      insert_unique(iterator __position, const value_type& __x);

      const_iterator
      insert_unique(const_iterator __position, const value_type& __x);

      iterator
      insert_equal(iterator __position, const value_type& __x);

      const_iterator
      insert_equal(const_iterator __position, const value_type& __x);

      template<typename _InputIterator>
        void
        insert_unique(_InputIterator __first, _InputIterator __last);

      template<typename _InputIterator>
        void
        insert_equal(_InputIterator __first, _InputIterator __last);

      void
      erase(iterator __position);

      void
      erase(const_iterator __position);

      size_type
      erase(const key_type& __x);

      void
      erase(iterator __first, iterator __last);

      void
      erase(const_iterator __first, const_iterator __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& __x);

      const_iterator
      find(const key_type& __x) const;

      size_type
      count(const key_type& __x) const;

      iterator
      lower_bound(const key_type& __x);

      const_iterator
      lower_bound(const key_type& __x) const;

      iterator
      upper_bound(const key_type& __x);

      const_iterator
      upper_bound(const key_type& __x) const;

      pair<iterator,iterator>
      equal_range(const key_type& __x);

      pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const;


      bool
      __rb_verify() const;
    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    {
      return __x.size() == __y.size()
      && std::equal(__x.begin(), __x.end(), __y.begin());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    {
      return std::lexicographical_compare(__x.begin(), __x.end(),
       __y.begin(), __y.end());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__x == __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return __y < __x; }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__y < __x); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline bool
    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { return !(__x < __y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { __x.swap(__y); }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
    {
      if (this != &__x)
 {

   clear();
   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
   if (__x._M_root() != 0)
     {
       _M_root() = _M_copy(__x._M_begin(), _M_end());
       _M_leftmost() = _S_minimum(_M_root());
       _M_rightmost() = _S_maximum(_M_root());
       _M_impl._M_node_count = __x._M_impl._M_node_count;
     }
 }
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert(_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>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || _M_impl._M_key_compare(_KeyOfValue()(__v),
            _S_key(__p)));

      _Link_type __z = _M_create_node(__v);

      _Rb_tree_insert_and_rebalance(__insert_left, __z,
        const_cast<_Base_ptr>(__p),
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return const_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>::
    insert_equal(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
         _S_left(__x) : _S_right(__x);
 }
      return _M_insert(__x, __y, __v);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    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);
    }

  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>::
    insert_unique(const _Val& __v)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();
      bool __comp = true;
      while (__x != 0)
 {
   __y = __x;
   __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
   __x = __comp ? _S_left(__x) : _S_right(__x);
 }
      iterator __j = iterator(__y);
      if (__comp)
 if (__j == begin())
   return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
 else
   --__j;
      if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
 return pair<iterator, bool>(_M_insert(__x, __y, __v), true);
      return pair<iterator, bool>(__j, false);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    insert_unique(iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()),
     _KeyOfValue()(__v)))
     return _M_insert(0, _M_rightmost(), __v);
   else
     return insert_unique(__v).first;
 }
      else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
          _S_key(__position._M_node)))
 {

   iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert(_M_leftmost(), _M_leftmost(), __v);
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
       _KeyOfValue()(__v)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert(0, __before._M_node, __v);
       else
  return _M_insert(__position._M_node,
     __position._M_node, __v);
     }
   else
     return insert_unique(__v).first;
 }
      else if (_M_impl._M_key_compare(_S_key(__position._M_node),
          _KeyOfValue()(__v)))
 {

   iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert(0, _M_rightmost(), __v);
   else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key((++__after)._M_node)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert(0, __position._M_node, __v);
       else
  return _M_insert(__after._M_node, __after._M_node, __v);
     }
   else
     return insert_unique(__v).first;
 }
      else
 return __position;
    }

  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>::
    insert_unique(const_iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()),
     _KeyOfValue()(__v)))
     return _M_insert(0, _M_rightmost(), __v);
   else
     return const_iterator(insert_unique(__v).first);
 }
      else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
          _S_key(__position._M_node)))
 {

   const_iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert(_M_leftmost(), _M_leftmost(), __v);
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
       _KeyOfValue()(__v)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert(0, __before._M_node, __v);
       else
  return _M_insert(__position._M_node,
     __position._M_node, __v);
     }
   else
     return const_iterator(insert_unique(__v).first);
 }
      else if (_M_impl._M_key_compare(_S_key(__position._M_node),
          _KeyOfValue()(__v)))
 {

   const_iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert(0, _M_rightmost(), __v);
   else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key((++__after)._M_node)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert(0, __position._M_node, __v);
       else
  return _M_insert(__after._M_node, __after._M_node, __v);
     }
   else
     return const_iterator(insert_unique(__v).first);
 }
      else
 return __position;
    }

  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>::
    insert_equal(iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(_KeyOfValue()(__v),
      _S_key(_M_rightmost())))
     return _M_insert(0, _M_rightmost(), __v);
   else
     return insert_equal(__v);
 }
      else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
           _KeyOfValue()(__v)))
 {

   iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert(_M_leftmost(), _M_leftmost(), __v);
   else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
        _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert(0, __before._M_node, __v);
       else
  return _M_insert(__position._M_node,
     __position._M_node, __v);
     }
   else
     return insert_equal(__v);
 }
      else
 {

   iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert(0, _M_rightmost(), __v);
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
        _KeyOfValue()(__v)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert(0, __position._M_node, __v);
       else
  return _M_insert(__after._M_node, __after._M_node, __v);
     }
   else
     return insert_equal(__v);
 }
    }

  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>::
    insert_equal(const_iterator __position, const _Val& __v)
    {

      if (__position._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(_KeyOfValue()(__v),
      _S_key(_M_rightmost())))
     return _M_insert(0, _M_rightmost(), __v);
   else
     return const_iterator(insert_equal(__v));
 }
      else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
           _KeyOfValue()(__v)))
 {

   const_iterator __before = __position;
   if (__position._M_node == _M_leftmost())
     return _M_insert(_M_leftmost(), _M_leftmost(), __v);
   else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
        _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _M_insert(0, __before._M_node, __v);
       else
  return _M_insert(__position._M_node,
     __position._M_node, __v);
     }
   else
     return const_iterator(insert_equal(__v));
 }
      else
 {

   const_iterator __after = __position;
   if (__position._M_node == _M_rightmost())
     return _M_insert(0, _M_rightmost(), __v);
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
        _KeyOfValue()(__v)))
     {
       if (_S_right(__position._M_node) == 0)
  return _M_insert(0, __position._M_node, __v);
       else
  return _M_insert(__after._M_node, __after._M_node, __v);
     }
   else
     return const_iterator(insert_equal(__v));
 }
    }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
      insert_equal(_II __first, _II __last)
      {
 for (; __first != __last; ++__first)
   insert_equal(end(), *__first);
      }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Cmp, typename _Alloc>
    template<class _II>
      void
      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
      insert_unique(_II __first, _II __last)
      {
 for (; __first != __last; ++__first)
   insert_unique(end(), *__first);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(iterator __position)
    {
      _Link_type __y =
 static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
    (__position._M_node,
     this->_M_impl._M_header));
      destroy_node(__y);
      --_M_impl._M_node_count;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(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));
      destroy_node(__y);
      --_M_impl._M_node_count;
    }

  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);
      size_type __n = std::distance(__p.first, __p.second);
      erase(__p.first, __p.second);
      return __n;
    }

  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);
   destroy_node(__x);
   __x = __y;
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(iterator __first, 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>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(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>
    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)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();

      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);

      iterator __j = iterator(__y);
      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_Link_type __x = _M_begin();
      _Const_Link_type __y = _M_end();

     while (__x != 0)
       {
  if (!_M_impl._M_key_compare(_S_key(__x), __k))
    __y = __x, __x = _S_left(__x);
  else
    __x = _S_right(__x);
       }
     const_iterator __j = const_iterator(__y);
     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;
    }

  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>::
    lower_bound(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))
   __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>::
    lower_bound(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))
   __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>::
    upper_bound(const _Key& __k)
    {
      _Link_type __x = _M_begin();
      _Link_type __y = _M_end();

      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>::
    upper_bound(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(__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>
    inline
    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)
    { return pair<iterator, iterator>(lower_bound(__k), upper_bound(__k)); }

  template<typename _Key, typename _Val, typename _KoV,
           typename _Compare, typename _Alloc>
    inline
    pair<typename _Rb_tree<_Key, _Val, _KoV,
      _Compare, _Alloc>::const_iterator,
  typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::const_iterator>
    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
    equal_range(const _Key& __k) const
    { return pair<const_iterator, const_iterator>(lower_bound(__k),
        upper_bound(__k)); }

  unsigned int
  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
                       const _Rb_tree_node_base* __root);

  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;
    }
}
# 66 "/usr/include/c++/4.1.3/set" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_set.h" 1 3
# 66 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
namespace std
{

  template<class _Key, class _Compare = std::less<_Key>,
    class _Alloc = std::allocator<_Key> >
    class set;

  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator==(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y);

  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator<(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y);
# 106 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
  template<class _Key, class _Compare, class _Alloc>
    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(_Compare(), allocator_type()) {}







      explicit
      set(const _Compare& __comp,
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) {}
# 177 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      template<class _InputIterator>
        set(_InputIterator __first, _InputIterator __last)
        : _M_t(_Compare(), allocator_type())
        { _M_t.insert_unique(__first, __last); }
# 193 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      template<class _InputIterator>
        set(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, __a)
        { _M_t.insert_unique(__first, __last); }
# 207 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      set(const set<_Key,_Compare,_Alloc>& __x)
      : _M_t(__x._M_t) { }
# 217 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      set<_Key,_Compare,_Alloc>&
      operator=(const set<_Key, _Compare, _Alloc>& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }




      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const
      { return _M_t.get_allocator(); }





      iterator
      begin() const
      { return _M_t.begin(); }





      iterator
      end() const
      { return _M_t.end(); }






      reverse_iterator
      rbegin() const
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() const
      { return _M_t.rend(); }


      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 299 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      void
      swap(set<_Key,_Compare,_Alloc>& __x)
      { _M_t.swap(__x._M_t); }
# 317 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      std::pair<iterator,bool>
      insert(const value_type& __x)
      {
 std::pair<typename _Rep_type::iterator, bool> __p =
   _M_t.insert_unique(__x);
 return std::pair<iterator, bool>(__p.first, __p.second);
      }
# 344 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t.insert_unique(__position, __x); }
# 356 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      template<class _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t.insert_unique(__first, __last); }
# 370 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 385 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 400 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }







      void
      clear()
      { _M_t.clear(); }
# 424 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
# 442 "/usr/include/c++/4.1.3/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); }
# 463 "/usr/include/c++/4.1.3/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); }
# 479 "/usr/include/c++/4.1.3/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); }
# 504 "/usr/include/c++/4.1.3/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<class _K1, class _C1, class _A1>
        friend bool
        operator== (const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);

      template<class _K1, class _C1, class _A1>
        friend bool
        operator< (const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);
    };
# 533 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator==(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 550 "/usr/include/c++/4.1.3/bits/stl_set.h" 3
  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator<(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator!=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator>(const set<_Key, _Compare, _Alloc>& __x,
       const set<_Key, _Compare, _Alloc>& __y)
    { return __y < __x; }


  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator<=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template<class _Key, class _Compare, class _Alloc>
    inline bool
    operator>=(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template<class _Key, class _Compare, class _Alloc>
    inline void
    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
    { __x.swap(__y); }

}
# 67 "/usr/include/c++/4.1.3/set" 2 3
# 1 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 1 3
# 66 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
namespace std
{


  template <class _Key, class _Compare = std::less<_Key>,
     class _Alloc = std::allocator<_Key> >
    class multiset;

  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y);

  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
       const multiset<_Key, _Compare, _Alloc>& __y);
# 104 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
  template <class _Key, class _Compare, class _Alloc>
    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(_Compare(), allocator_type()) { }

      explicit
      multiset(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, __a) { }
# 168 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      template <class _InputIterator>
        multiset(_InputIterator __first, _InputIterator __last)
 : _M_t(_Compare(), allocator_type())
        { _M_t.insert_equal(__first, __last); }
# 184 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      template <class _InputIterator>
        multiset(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, __a)
        { _M_t.insert_equal(__first, __last); }
# 198 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      multiset(const multiset<_Key,_Compare,_Alloc>& __x)
      : _M_t(__x._M_t) { }
# 208 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      multiset<_Key,_Compare,_Alloc>&
      operator=(const multiset<_Key,_Compare,_Alloc>& __x)
      {
 _M_t = __x._M_t;
 return *this;
      }




      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const
      { return _M_t.get_allocator(); }






      iterator
      begin() const
      { return _M_t.begin(); }






      iterator
      end() const
      { return _M_t.end(); }






      reverse_iterator
      rbegin() const
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() const
      { return _M_t.rend(); }


      bool
      empty() const
      { return _M_t.empty(); }


      size_type
      size() const
      { return _M_t.size(); }


      size_type
      max_size() const
      { return _M_t.max_size(); }
# 292 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      void
      swap(multiset<_Key, _Compare, _Alloc>& __x)
      { _M_t.swap(__x._M_t); }
# 308 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t.insert_equal(__x); }
# 332 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      iterator
      insert(iterator __position, const value_type& __x)
      { return _M_t.insert_equal(__position, __x); }
# 344 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      template <class _InputIterator>
        void
        insert(_InputIterator __first, _InputIterator __last)
        { _M_t.insert_equal(__first, __last); }
# 359 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      void
      erase(iterator __position)
      { _M_t.erase(__position); }
# 374 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 389 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      void
      erase(iterator __first, iterator __last)
      { _M_t.erase(__first, __last); }







      void
      clear()
      { _M_t.clear(); }
# 410 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }
# 428 "/usr/include/c++/4.1.3/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); }
# 449 "/usr/include/c++/4.1.3/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); }
# 465 "/usr/include/c++/4.1.3/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); }
# 490 "/usr/include/c++/4.1.3/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 <class _K1, class _C1, class _A1>
        friend bool
        operator== (const multiset<_K1, _C1, _A1>&,
      const multiset<_K1, _C1, _A1>&);

      template <class _K1, class _C1, class _A1>
        friend bool
        operator< (const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);
    };
# 520 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 537 "/usr/include/c++/4.1.3/bits/stl_multiset.h" 3
  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator<(const multiset<_Key, _Compare, _Alloc>& __x,
       const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t < __y._M_t; }


  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator!=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__x == __y); }


  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator>(const multiset<_Key,_Compare,_Alloc>& __x,
       const multiset<_Key,_Compare,_Alloc>& __y)
    { return __y < __x; }


  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator<=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__y < __x); }


  template <class _Key, class _Compare, class _Alloc>
    inline bool
    operator>=(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return !(__x < __y); }


  template <class _Key, class _Compare, class _Alloc>
    inline void
    swap(multiset<_Key, _Compare, _Alloc>& __x,
  multiset<_Key, _Compare, _Alloc>& __y)
    { __x.swap(__y); }

}
# 68 "/usr/include/c++/4.1.3/set" 2 3
# 5 "/scratch/mcrl2_regressiontest/trunk/3rd-party/aterm/include/aterm/protaterm.h" 2


class IProtectedATerm
{
  typedef std::multiset< IProtectedATerm* > pa_container;

  protected:

    static void AT_protectProtectedATerms()
    {
      for (pa_container::iterator i=p_aterms().begin(); i!=p_aterms().end(); i++)
      {
        (*i)->ATprotectTerms();
      }
    }

    static pa_container initialise_p_aterms()
    {
      ATaddProtectFunction(AT_protectProtectedATerms);
      return pa_container();
    }

    static pa_container &p_aterms()
    {
      static pa_container _p_aterms = initialise_p_aterms();
      return _p_aterms;
    }

    void ATprotectProtectedATerm(IProtectedATerm *i)
    {
      p_aterms().insert(i);
    }

    void ATunprotectProtectedATerm(IProtectedATerm *i)
    {
      p_aterms().erase(p_aterms().find(i));
    }

  public:

    virtual void ATprotectTerms() = 0;

    virtual ~IProtectedATerm() = 0;
};

inline IProtectedATerm::~IProtectedATerm()
{
}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/vector.h" 2

namespace atermpp {


template <class T, class Allocator = std::allocator<T> >
class vector: public std::vector<T,Allocator>, IProtectedATerm
{
  public:

    vector()
      : IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }



    explicit vector(const Allocator& a)
      : std::vector<T,Allocator>(a),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }



    explicit vector(typename std::vector<T,Allocator>::size_type count)
      : std::vector<T,Allocator>(count),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }




    vector(typename std::vector<T,Allocator>::size_type count, const T& val)
      : std::vector<T,Allocator>(count, val),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }





    vector(typename std::vector<T,Allocator>::size_type count, const T& val, const Allocator& a)
      : std::vector<T,Allocator>(count, val, a),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }



    vector(const vector& right)
      : std::vector<T,Allocator>(right),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }




    template<class InIt>
        vector(InIt first, InIt last)
      : std::vector<T,Allocator>(first, last),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }





    template<class InIt>
        vector(InIt first, InIt last, const Allocator& a)
      : std::vector<T,Allocator>(first, last, a),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }


    ~vector()
    {
      ATunprotectProtectedATerm(this);
    }


    void ATprotectTerms()
    {



      for (typename std::vector<T,Allocator>::iterator i = std::vector<T,Allocator>::begin(); i != std::vector<T,Allocator>::end(); ++i)
      {
        aterm_traits<T>::mark(*i);
      }
    }
};

}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/constructors.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/constructors.h"
namespace mcrl2 {

namespace core {

namespace detail {


inline
ATermAppl initConstructString(ATermAppl& t)
{
  t = gsString2ATermAppl("@NoValue");
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructString()
{
  static ATermAppl t = initConstructString(t);
  return t;
}


inline
ATermList constructList()
{
  return (ATempty);
}


ATermAppl constructBooleanOr();
ATermAppl constructStateOr();
ATermAppl constructHide();
ATermAppl constructSortArrow();
ATermAppl constructProcessAssignment();
ATermAppl constructForall();
ATermAppl constructCommExpr();
ATermAppl constructStateNot();
ATermAppl constructBooleanFalse();
ATermAppl constructSortFSet();
ATermAppl constructStateImp();
ATermAppl constructPBESExists();
ATermAppl constructPBESImp();
ATermAppl constructBinder();
ATermAppl constructSortsPossible();
ATermAppl constructSortRef();
ATermAppl constructProcEqnSpec();
ATermAppl constructStateForall();
ATermAppl constructBooleanImp();
ATermAppl constructSortId();
ATermAppl constructStateNu();
ATermAppl constructRegNil();
ATermAppl constructDataSpec();
ATermAppl constructTau();
ATermAppl constructStateYaledTimed();
ATermAppl constructSortCons();
ATermAppl constructDataEqnSpec();
ATermAppl constructLinearProcessSummand();
ATermAppl constructSortSpec();
ATermAppl constructActionRenameRules();
ATermAppl constructBooleanEquation();
ATermAppl constructConsSpec();
ATermAppl constructSortList();
ATermAppl constructSum();
ATermAppl constructDataVarId();
ATermAppl constructProcVarId();
ATermAppl constructProcessInit();
ATermAppl constructBES();
ATermAppl constructMapSpec();
ATermAppl constructStateYaled();
ATermAppl constructBooleanAnd();
ATermAppl constructLinProcSpec();
ATermAppl constructSetBagComp();
ATermAppl constructChoice();
ATermAppl constructLinearProcessInit();
ATermAppl constructMultAct();
ATermAppl constructPropVarInst();
ATermAppl constructBagComp();
ATermAppl constructStateDelay();
ATermAppl constructIdAssignment();
ATermAppl constructRegAlt();
ATermAppl constructStructCons();
ATermAppl constructIdInit();
ATermAppl constructMu();
ATermAppl constructPBEqnSpec();
ATermAppl constructActNot();
ATermAppl constructBooleanTrue();
ATermAppl constructBlock();
ATermAppl constructRename();
ATermAppl constructExists();
ATermAppl constructSync();
ATermAppl constructActExists();
ATermAppl constructProcSpec();
ATermAppl constructStateMu();
ATermAppl constructStateFalse();
ATermAppl constructPBESForall();
ATermAppl constructStateTrue();
ATermAppl constructBInit();
ATermAppl constructPBESFalse();
ATermAppl constructDataAppl();
ATermAppl constructRegTrans();
ATermAppl constructStateDelayTimed();
ATermAppl constructNu();
ATermAppl constructSortStruct();
ATermAppl constructAtTime();
ATermAppl constructActOr();
ATermAppl constructComm();
ATermAppl constructBooleanNot();
ATermAppl constructDelta();
ATermAppl constructStateAnd();
ATermAppl constructLMerge();
ATermAppl constructSetComp();
ATermAppl constructActForall();
ATermAppl constructRenameExpr();
ATermAppl constructMerge();
ATermAppl constructIfThen();
ATermAppl constructBooleanVariable();
ATermAppl constructAction();
ATermAppl constructPBESAnd();
ATermAppl constructLambda();
ATermAppl constructStateMust();
ATermAppl constructSeq();
ATermAppl constructDataVarIdInit();
ATermAppl constructProcess();
ATermAppl constructActAnd();
ATermAppl constructActionRenameSpec();
ATermAppl constructPBES();
ATermAppl constructStateVar();
ATermAppl constructActionRenameRule();
ATermAppl constructLinearProcess();
ATermAppl constructActAt();
ATermAppl constructDataEqn();
ATermAppl constructPBESNot();
ATermAppl constructStateExists();
ATermAppl constructStateMay();
ATermAppl constructParamId();
ATermAppl constructPBESTrue();
ATermAppl constructMultActName();
ATermAppl constructIfThenElse();
ATermAppl constructNil();
ATermAppl constructProcEqn();
ATermAppl constructStructProj();
ATermAppl constructPBEqn();
ATermAppl constructWhr();
ATermAppl constructOpId();
ATermAppl constructSortSet();
ATermAppl constructActFalse();
ATermAppl constructActId();
ATermAppl constructSortUnknown();
ATermAppl constructPBESOr();
ATermAppl constructRegSeq();
ATermAppl constructSortFBag();
ATermAppl constructAllow();
ATermAppl constructPropVarDecl();
ATermAppl constructActImp();
ATermAppl constructSortBag();
ATermAppl constructPBInit();
ATermAppl constructActTrue();
ATermAppl constructRegTransOrNil();
ATermAppl constructGlobVarSpec();
ATermAppl constructActSpec();
ATermAppl constructId();
ATermAppl constructSortExpr();
ATermAppl constructSortConsType();
ATermAppl constructStringOrNil();
ATermAppl constructDataExpr();
ATermAppl constructBindingOperator();
ATermAppl constructWhrDecl();
ATermAppl constructSortDecl();
ATermAppl constructDataExprOrNil();
ATermAppl constructParamIdOrAction();
ATermAppl constructProcExpr();
ATermAppl constructMultActOrDelta();
ATermAppl constructProcInit();
ATermAppl constructStateFrm();
ATermAppl constructRegFrm();
ATermAppl constructActFrm();
ATermAppl constructActionRenameRuleRHS();
ATermAppl constructFixPoint();
ATermAppl constructPBExpr();
ATermAppl constructBooleanExpression();


inline
ATermAppl initConstructBooleanOr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunBooleanOr(), reinterpret_cast<ATerm>(constructBooleanExpression()), reinterpret_cast<ATerm>(constructBooleanExpression()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanOr()
{
  static ATermAppl t = initConstructBooleanOr(t);
  return t;
}


inline
ATermAppl initConstructStateOr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateOr(), reinterpret_cast<ATerm>(constructStateFrm()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateOr()
{
  static ATermAppl t = initConstructStateOr(t);
  return t;
}


inline
ATermAppl initConstructHide(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunHide(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructHide()
{
  static ATermAppl t = initConstructHide(t);
  return t;
}


inline
ATermAppl initConstructSortArrow(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunSortArrow(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructSortExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortArrow()
{
  static ATermAppl t = initConstructSortArrow(t);
  return t;
}


inline
ATermAppl initConstructProcessAssignment(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunProcessAssignment(), reinterpret_cast<ATerm>(constructProcVarId()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcessAssignment()
{
  static ATermAppl t = initConstructProcessAssignment(t);
  return t;
}


inline
ATermAppl initConstructForall(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunForall());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructForall()
{
  static ATermAppl t = initConstructForall(t);
  return t;
}


inline
ATermAppl initConstructCommExpr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunCommExpr(), reinterpret_cast<ATerm>(constructMultActName()), reinterpret_cast<ATerm>(constructStringOrNil()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructCommExpr()
{
  static ATermAppl t = initConstructCommExpr(t);
  return t;
}


inline
ATermAppl initConstructStateNot(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunStateNot(), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateNot()
{
  static ATermAppl t = initConstructStateNot(t);
  return t;
}


inline
ATermAppl initConstructBooleanFalse(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunBooleanFalse());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanFalse()
{
  static ATermAppl t = initConstructBooleanFalse(t);
  return t;
}


inline
ATermAppl initConstructSortFSet(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSortFSet());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortFSet()
{
  static ATermAppl t = initConstructSortFSet(t);
  return t;
}


inline
ATermAppl initConstructStateImp(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateImp(), reinterpret_cast<ATerm>(constructStateFrm()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateImp()
{
  static ATermAppl t = initConstructStateImp(t);
  return t;
}


inline
ATermAppl initConstructPBESExists(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPBESExists(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESExists()
{
  static ATermAppl t = initConstructPBESExists(t);
  return t;
}


inline
ATermAppl initConstructPBESImp(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPBESImp(), reinterpret_cast<ATerm>(constructPBExpr()), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESImp()
{
  static ATermAppl t = initConstructPBESImp(t);
  return t;
}


inline
ATermAppl initConstructBinder(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunBinder(), reinterpret_cast<ATerm>(constructBindingOperator()), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBinder()
{
  static ATermAppl t = initConstructBinder(t);
  return t;
}


inline
ATermAppl initConstructSortsPossible(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunSortsPossible(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortsPossible()
{
  static ATermAppl t = initConstructSortsPossible(t);
  return t;
}


inline
ATermAppl initConstructSortRef(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunSortRef(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructSortExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortRef()
{
  static ATermAppl t = initConstructSortRef(t);
  return t;
}


inline
ATermAppl initConstructProcEqnSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunProcEqnSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcEqnSpec()
{
  static ATermAppl t = initConstructProcEqnSpec(t);
  return t;
}


inline
ATermAppl initConstructStateForall(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateForall(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateForall()
{
  static ATermAppl t = initConstructStateForall(t);
  return t;
}


inline
ATermAppl initConstructBooleanImp(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunBooleanImp(), reinterpret_cast<ATerm>(constructBooleanExpression()), reinterpret_cast<ATerm>(constructBooleanExpression()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanImp()
{
  static ATermAppl t = initConstructBooleanImp(t);
  return t;
}


inline
ATermAppl initConstructSortId(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunSortId(), reinterpret_cast<ATerm>(constructString()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortId()
{
  static ATermAppl t = initConstructSortId(t);
  return t;
}


inline
ATermAppl initConstructStateNu(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunStateNu(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateNu()
{
  static ATermAppl t = initConstructStateNu(t);
  return t;
}


inline
ATermAppl initConstructRegNil(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunRegNil());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRegNil()
{
  static ATermAppl t = initConstructRegNil(t);
  return t;
}


inline
ATermAppl initConstructDataSpec(ATermAppl& t)
{
  t = ATmakeAppl4(gsAFunDataSpec(), reinterpret_cast<ATerm>(constructSortSpec()), reinterpret_cast<ATerm>(constructConsSpec()), reinterpret_cast<ATerm>(constructMapSpec()), reinterpret_cast<ATerm>(constructDataEqnSpec()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDataSpec()
{
  static ATermAppl t = initConstructDataSpec(t);
  return t;
}


inline
ATermAppl initConstructTau(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunTau());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructTau()
{
  static ATermAppl t = initConstructTau(t);
  return t;
}


inline
ATermAppl initConstructStateYaledTimed(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunStateYaledTimed(), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateYaledTimed()
{
  static ATermAppl t = initConstructStateYaledTimed(t);
  return t;
}


inline
ATermAppl initConstructSortCons(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunSortCons(), reinterpret_cast<ATerm>(constructSortConsType()), reinterpret_cast<ATerm>(constructSortExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortCons()
{
  static ATermAppl t = initConstructSortCons(t);
  return t;
}


inline
ATermAppl initConstructDataEqnSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunDataEqnSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDataEqnSpec()
{
  static ATermAppl t = initConstructDataEqnSpec(t);
  return t;
}


inline
ATermAppl initConstructLinearProcessSummand(ATermAppl& t)
{
  t = ATmakeAppl5(gsAFunLinearProcessSummand(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructMultActOrDelta()), reinterpret_cast<ATerm>(constructDataExprOrNil()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructLinearProcessSummand()
{
  static ATermAppl t = initConstructLinearProcessSummand(t);
  return t;
}


inline
ATermAppl initConstructSortSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunSortSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortSpec()
{
  static ATermAppl t = initConstructSortSpec(t);
  return t;
}


inline
ATermAppl initConstructActionRenameRules(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunActionRenameRules(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActionRenameRules()
{
  static ATermAppl t = initConstructActionRenameRules(t);
  return t;
}


inline
ATermAppl initConstructBooleanEquation(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunBooleanEquation(), reinterpret_cast<ATerm>(constructFixPoint()), reinterpret_cast<ATerm>(constructBooleanVariable()), reinterpret_cast<ATerm>(constructBooleanExpression()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanEquation()
{
  static ATermAppl t = initConstructBooleanEquation(t);
  return t;
}


inline
ATermAppl initConstructConsSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunConsSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructConsSpec()
{
  static ATermAppl t = initConstructConsSpec(t);
  return t;
}


inline
ATermAppl initConstructSortList(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSortList());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortList()
{
  static ATermAppl t = initConstructSortList(t);
  return t;
}


inline
ATermAppl initConstructSum(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunSum(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSum()
{
  static ATermAppl t = initConstructSum(t);
  return t;
}


inline
ATermAppl initConstructDataVarId(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunDataVarId(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructSortExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDataVarId()
{
  static ATermAppl t = initConstructDataVarId(t);
  return t;
}


inline
ATermAppl initConstructProcVarId(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunProcVarId(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcVarId()
{
  static ATermAppl t = initConstructProcVarId(t);
  return t;
}


inline
ATermAppl initConstructProcessInit(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunProcessInit(), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcessInit()
{
  static ATermAppl t = initConstructProcessInit(t);
  return t;
}


inline
ATermAppl initConstructBES(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunBES(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructBooleanExpression()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBES()
{
  static ATermAppl t = initConstructBES(t);
  return t;
}


inline
ATermAppl initConstructMapSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunMapSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructMapSpec()
{
  static ATermAppl t = initConstructMapSpec(t);
  return t;
}


inline
ATermAppl initConstructStateYaled(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunStateYaled());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateYaled()
{
  static ATermAppl t = initConstructStateYaled(t);
  return t;
}


inline
ATermAppl initConstructBooleanAnd(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunBooleanAnd(), reinterpret_cast<ATerm>(constructBooleanExpression()), reinterpret_cast<ATerm>(constructBooleanExpression()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanAnd()
{
  static ATermAppl t = initConstructBooleanAnd(t);
  return t;
}


inline
ATermAppl initConstructLinProcSpec(ATermAppl& t)
{
  t = ATmakeAppl5(gsAFunLinProcSpec(), reinterpret_cast<ATerm>(constructDataSpec()), reinterpret_cast<ATerm>(constructActSpec()), reinterpret_cast<ATerm>(constructGlobVarSpec()), reinterpret_cast<ATerm>(constructLinearProcess()), reinterpret_cast<ATerm>(constructLinearProcessInit()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructLinProcSpec()
{
  static ATermAppl t = initConstructLinProcSpec(t);
  return t;
}


inline
ATermAppl initConstructSetBagComp(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSetBagComp());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSetBagComp()
{
  static ATermAppl t = initConstructSetBagComp(t);
  return t;
}


inline
ATermAppl initConstructChoice(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunChoice(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructChoice()
{
  static ATermAppl t = initConstructChoice(t);
  return t;
}


inline
ATermAppl initConstructLinearProcessInit(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunLinearProcessInit(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructLinearProcessInit()
{
  static ATermAppl t = initConstructLinearProcessInit(t);
  return t;
}


inline
ATermAppl initConstructMultAct(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunMultAct(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructMultAct()
{
  static ATermAppl t = initConstructMultAct(t);
  return t;
}


inline
ATermAppl initConstructPropVarInst(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPropVarInst(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPropVarInst()
{
  static ATermAppl t = initConstructPropVarInst(t);
  return t;
}


inline
ATermAppl initConstructBagComp(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunBagComp());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBagComp()
{
  static ATermAppl t = initConstructBagComp(t);
  return t;
}


inline
ATermAppl initConstructStateDelay(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunStateDelay());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateDelay()
{
  static ATermAppl t = initConstructStateDelay(t);
  return t;
}


inline
ATermAppl initConstructIdAssignment(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunIdAssignment(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructIdAssignment()
{
  static ATermAppl t = initConstructIdAssignment(t);
  return t;
}


inline
ATermAppl initConstructRegAlt(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunRegAlt(), reinterpret_cast<ATerm>(constructRegFrm()), reinterpret_cast<ATerm>(constructRegFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRegAlt()
{
  static ATermAppl t = initConstructRegAlt(t);
  return t;
}


inline
ATermAppl initConstructStructCons(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunStructCons(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructStringOrNil()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStructCons()
{
  static ATermAppl t = initConstructStructCons(t);
  return t;
}


inline
ATermAppl initConstructIdInit(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunIdInit(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructIdInit()
{
  static ATermAppl t = initConstructIdInit(t);
  return t;
}


inline
ATermAppl initConstructMu(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunMu());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructMu()
{
  static ATermAppl t = initConstructMu(t);
  return t;
}


inline
ATermAppl initConstructPBEqnSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunPBEqnSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBEqnSpec()
{
  static ATermAppl t = initConstructPBEqnSpec(t);
  return t;
}


inline
ATermAppl initConstructActNot(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunActNot(), reinterpret_cast<ATerm>(constructActFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActNot()
{
  static ATermAppl t = initConstructActNot(t);
  return t;
}


inline
ATermAppl initConstructBooleanTrue(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunBooleanTrue());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanTrue()
{
  static ATermAppl t = initConstructBooleanTrue(t);
  return t;
}


inline
ATermAppl initConstructBlock(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunBlock(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBlock()
{
  static ATermAppl t = initConstructBlock(t);
  return t;
}


inline
ATermAppl initConstructRename(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunRename(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRename()
{
  static ATermAppl t = initConstructRename(t);
  return t;
}


inline
ATermAppl initConstructExists(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunExists());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructExists()
{
  static ATermAppl t = initConstructExists(t);
  return t;
}


inline
ATermAppl initConstructSync(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunSync(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSync()
{
  static ATermAppl t = initConstructSync(t);
  return t;
}


inline
ATermAppl initConstructActExists(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActExists(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructActFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActExists()
{
  static ATermAppl t = initConstructActExists(t);
  return t;
}


inline
ATermAppl initConstructProcSpec(ATermAppl& t)
{
  t = ATmakeAppl5(gsAFunProcSpec(), reinterpret_cast<ATerm>(constructDataSpec()), reinterpret_cast<ATerm>(constructActSpec()), reinterpret_cast<ATerm>(constructGlobVarSpec()), reinterpret_cast<ATerm>(constructProcEqnSpec()), reinterpret_cast<ATerm>(constructProcInit()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcSpec()
{
  static ATermAppl t = initConstructProcSpec(t);
  return t;
}


inline
ATermAppl initConstructStateMu(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunStateMu(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateMu()
{
  static ATermAppl t = initConstructStateMu(t);
  return t;
}


inline
ATermAppl initConstructStateFalse(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunStateFalse());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateFalse()
{
  static ATermAppl t = initConstructStateFalse(t);
  return t;
}


inline
ATermAppl initConstructPBESForall(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPBESForall(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESForall()
{
  static ATermAppl t = initConstructPBESForall(t);
  return t;
}


inline
ATermAppl initConstructStateTrue(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunStateTrue());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateTrue()
{
  static ATermAppl t = initConstructStateTrue(t);
  return t;
}


inline
ATermAppl initConstructBInit(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunBInit(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBInit()
{
  static ATermAppl t = initConstructBInit(t);
  return t;
}


inline
ATermAppl initConstructPBESFalse(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunPBESFalse());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESFalse()
{
  static ATermAppl t = initConstructPBESFalse(t);
  return t;
}


inline
ATermAppl initConstructDataAppl(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunDataAppl(), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDataAppl()
{
  static ATermAppl t = initConstructDataAppl(t);
  return t;
}


inline
ATermAppl initConstructRegTrans(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunRegTrans(), reinterpret_cast<ATerm>(constructRegFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRegTrans()
{
  static ATermAppl t = initConstructRegTrans(t);
  return t;
}


inline
ATermAppl initConstructStateDelayTimed(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunStateDelayTimed(), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateDelayTimed()
{
  static ATermAppl t = initConstructStateDelayTimed(t);
  return t;
}


inline
ATermAppl initConstructNu(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunNu());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructNu()
{
  static ATermAppl t = initConstructNu(t);
  return t;
}


inline
ATermAppl initConstructSortStruct(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunSortStruct(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortStruct()
{
  static ATermAppl t = initConstructSortStruct(t);
  return t;
}


inline
ATermAppl initConstructAtTime(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunAtTime(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructAtTime()
{
  static ATermAppl t = initConstructAtTime(t);
  return t;
}


inline
ATermAppl initConstructActOr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActOr(), reinterpret_cast<ATerm>(constructActFrm()), reinterpret_cast<ATerm>(constructActFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActOr()
{
  static ATermAppl t = initConstructActOr(t);
  return t;
}


inline
ATermAppl initConstructComm(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunComm(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructComm()
{
  static ATermAppl t = initConstructComm(t);
  return t;
}


inline
ATermAppl initConstructBooleanNot(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunBooleanNot(), reinterpret_cast<ATerm>(constructBooleanExpression()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanNot()
{
  static ATermAppl t = initConstructBooleanNot(t);
  return t;
}


inline
ATermAppl initConstructDelta(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunDelta());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDelta()
{
  static ATermAppl t = initConstructDelta(t);
  return t;
}


inline
ATermAppl initConstructStateAnd(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateAnd(), reinterpret_cast<ATerm>(constructStateFrm()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateAnd()
{
  static ATermAppl t = initConstructStateAnd(t);
  return t;
}


inline
ATermAppl initConstructLMerge(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunLMerge(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructLMerge()
{
  static ATermAppl t = initConstructLMerge(t);
  return t;
}


inline
ATermAppl initConstructSetComp(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSetComp());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSetComp()
{
  static ATermAppl t = initConstructSetComp(t);
  return t;
}


inline
ATermAppl initConstructActForall(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActForall(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructActFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActForall()
{
  static ATermAppl t = initConstructActForall(t);
  return t;
}


inline
ATermAppl initConstructRenameExpr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunRenameExpr(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructString()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRenameExpr()
{
  static ATermAppl t = initConstructRenameExpr(t);
  return t;
}


inline
ATermAppl initConstructMerge(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunMerge(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructMerge()
{
  static ATermAppl t = initConstructMerge(t);
  return t;
}


inline
ATermAppl initConstructIfThen(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunIfThen(), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructIfThen()
{
  static ATermAppl t = initConstructIfThen(t);
  return t;
}


inline
ATermAppl initConstructBooleanVariable(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunBooleanVariable(), reinterpret_cast<ATerm>(constructString()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructBooleanVariable()
{
  static ATermAppl t = initConstructBooleanVariable(t);
  return t;
}


inline
ATermAppl initConstructAction(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunAction(), reinterpret_cast<ATerm>(constructActId()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructAction()
{
  static ATermAppl t = initConstructAction(t);
  return t;
}


inline
ATermAppl initConstructPBESAnd(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPBESAnd(), reinterpret_cast<ATerm>(constructPBExpr()), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESAnd()
{
  static ATermAppl t = initConstructPBESAnd(t);
  return t;
}


inline
ATermAppl initConstructLambda(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunLambda());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructLambda()
{
  static ATermAppl t = initConstructLambda(t);
  return t;
}


inline
ATermAppl initConstructStateMust(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateMust(), reinterpret_cast<ATerm>(constructRegFrm()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateMust()
{
  static ATermAppl t = initConstructStateMust(t);
  return t;
}


inline
ATermAppl initConstructSeq(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunSeq(), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSeq()
{
  static ATermAppl t = initConstructSeq(t);
  return t;
}


inline
ATermAppl initConstructDataVarIdInit(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunDataVarIdInit(), reinterpret_cast<ATerm>(constructDataVarId()), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDataVarIdInit()
{
  static ATermAppl t = initConstructDataVarIdInit(t);
  return t;
}


inline
ATermAppl initConstructProcess(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunProcess(), reinterpret_cast<ATerm>(constructProcVarId()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcess()
{
  static ATermAppl t = initConstructProcess(t);
  return t;
}


inline
ATermAppl initConstructActAnd(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActAnd(), reinterpret_cast<ATerm>(constructActFrm()), reinterpret_cast<ATerm>(constructActFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActAnd()
{
  static ATermAppl t = initConstructActAnd(t);
  return t;
}


inline
ATermAppl initConstructActionRenameSpec(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunActionRenameSpec(), reinterpret_cast<ATerm>(constructDataSpec()), reinterpret_cast<ATerm>(constructActSpec()), reinterpret_cast<ATerm>(constructActionRenameRules()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActionRenameSpec()
{
  static ATermAppl t = initConstructActionRenameSpec(t);
  return t;
}


inline
ATermAppl initConstructPBES(ATermAppl& t)
{
  t = ATmakeAppl4(gsAFunPBES(), reinterpret_cast<ATerm>(constructDataSpec()), reinterpret_cast<ATerm>(constructGlobVarSpec()), reinterpret_cast<ATerm>(constructPBEqnSpec()), reinterpret_cast<ATerm>(constructPBInit()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBES()
{
  static ATermAppl t = initConstructPBES(t);
  return t;
}


inline
ATermAppl initConstructStateVar(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateVar(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateVar()
{
  static ATermAppl t = initConstructStateVar(t);
  return t;
}


inline
ATermAppl initConstructActionRenameRule(ATermAppl& t)
{
  t = ATmakeAppl4(gsAFunActionRenameRule(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructParamIdOrAction()), reinterpret_cast<ATerm>(constructActionRenameRuleRHS()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActionRenameRule()
{
  static ATermAppl t = initConstructActionRenameRule(t);
  return t;
}


inline
ATermAppl initConstructLinearProcess(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunLinearProcess(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructLinearProcess()
{
  static ATermAppl t = initConstructLinearProcess(t);
  return t;
}


inline
ATermAppl initConstructActAt(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActAt(), reinterpret_cast<ATerm>(constructActFrm()), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActAt()
{
  static ATermAppl t = initConstructActAt(t);
  return t;
}


inline
ATermAppl initConstructDataEqn(ATermAppl& t)
{
  t = ATmakeAppl4(gsAFunDataEqn(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructDataExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructDataEqn()
{
  static ATermAppl t = initConstructDataEqn(t);
  return t;
}


inline
ATermAppl initConstructPBESNot(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunPBESNot(), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESNot()
{
  static ATermAppl t = initConstructPBESNot(t);
  return t;
}


inline
ATermAppl initConstructStateExists(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateExists(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateExists()
{
  static ATermAppl t = initConstructStateExists(t);
  return t;
}


inline
ATermAppl initConstructStateMay(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStateMay(), reinterpret_cast<ATerm>(constructRegFrm()), reinterpret_cast<ATerm>(constructStateFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStateMay()
{
  static ATermAppl t = initConstructStateMay(t);
  return t;
}


inline
ATermAppl initConstructParamId(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunParamId(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructParamId()
{
  static ATermAppl t = initConstructParamId(t);
  return t;
}


inline
ATermAppl initConstructPBESTrue(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunPBESTrue());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESTrue()
{
  static ATermAppl t = initConstructPBESTrue(t);
  return t;
}


inline
ATermAppl initConstructMultActName(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunMultActName(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructMultActName()
{
  static ATermAppl t = initConstructMultActName(t);
  return t;
}


inline
ATermAppl initConstructIfThenElse(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunIfThenElse(), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructProcExpr()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructIfThenElse()
{
  static ATermAppl t = initConstructIfThenElse(t);
  return t;
}


inline
ATermAppl initConstructNil(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunNil());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructNil()
{
  static ATermAppl t = initConstructNil(t);
  return t;
}


inline
ATermAppl initConstructProcEqn(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunProcEqn(), reinterpret_cast<ATerm>(constructProcVarId()), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructProcEqn()
{
  static ATermAppl t = initConstructProcEqn(t);
  return t;
}


inline
ATermAppl initConstructStructProj(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunStructProj(), reinterpret_cast<ATerm>(constructStringOrNil()), reinterpret_cast<ATerm>(constructSortExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructStructProj()
{
  static ATermAppl t = initConstructStructProj(t);
  return t;
}


inline
ATermAppl initConstructPBEqn(ATermAppl& t)
{
  t = ATmakeAppl3(gsAFunPBEqn(), reinterpret_cast<ATerm>(constructFixPoint()), reinterpret_cast<ATerm>(constructPropVarDecl()), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBEqn()
{
  static ATermAppl t = initConstructPBEqn(t);
  return t;
}


inline
ATermAppl initConstructWhr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunWhr(), reinterpret_cast<ATerm>(constructDataExpr()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructWhr()
{
  static ATermAppl t = initConstructWhr(t);
  return t;
}


inline
ATermAppl initConstructOpId(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunOpId(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructSortExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructOpId()
{
  static ATermAppl t = initConstructOpId(t);
  return t;
}


inline
ATermAppl initConstructSortSet(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSortSet());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortSet()
{
  static ATermAppl t = initConstructSortSet(t);
  return t;
}


inline
ATermAppl initConstructActFalse(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunActFalse());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActFalse()
{
  static ATermAppl t = initConstructActFalse(t);
  return t;
}


inline
ATermAppl initConstructActId(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActId(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActId()
{
  static ATermAppl t = initConstructActId(t);
  return t;
}


inline
ATermAppl initConstructSortUnknown(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSortUnknown());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortUnknown()
{
  static ATermAppl t = initConstructSortUnknown(t);
  return t;
}


inline
ATermAppl initConstructPBESOr(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPBESOr(), reinterpret_cast<ATerm>(constructPBExpr()), reinterpret_cast<ATerm>(constructPBExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBESOr()
{
  static ATermAppl t = initConstructPBESOr(t);
  return t;
}


inline
ATermAppl initConstructRegSeq(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunRegSeq(), reinterpret_cast<ATerm>(constructRegFrm()), reinterpret_cast<ATerm>(constructRegFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRegSeq()
{
  static ATermAppl t = initConstructRegSeq(t);
  return t;
}


inline
ATermAppl initConstructSortFBag(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSortFBag());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortFBag()
{
  static ATermAppl t = initConstructSortFBag(t);
  return t;
}


inline
ATermAppl initConstructAllow(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunAllow(), reinterpret_cast<ATerm>(constructList()), reinterpret_cast<ATerm>(constructProcExpr()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructAllow()
{
  static ATermAppl t = initConstructAllow(t);
  return t;
}


inline
ATermAppl initConstructPropVarDecl(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunPropVarDecl(), reinterpret_cast<ATerm>(constructString()), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPropVarDecl()
{
  static ATermAppl t = initConstructPropVarDecl(t);
  return t;
}


inline
ATermAppl initConstructActImp(ATermAppl& t)
{
  t = ATmakeAppl2(gsAFunActImp(), reinterpret_cast<ATerm>(constructActFrm()), reinterpret_cast<ATerm>(constructActFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActImp()
{
  static ATermAppl t = initConstructActImp(t);
  return t;
}


inline
ATermAppl initConstructSortBag(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunSortBag());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructSortBag()
{
  static ATermAppl t = initConstructSortBag(t);
  return t;
}


inline
ATermAppl initConstructPBInit(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunPBInit(), reinterpret_cast<ATerm>(constructPropVarInst()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructPBInit()
{
  static ATermAppl t = initConstructPBInit(t);
  return t;
}


inline
ATermAppl initConstructActTrue(ATermAppl& t)
{
  t = ATmakeAppl0(gsAFunActTrue());
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActTrue()
{
  static ATermAppl t = initConstructActTrue(t);
  return t;
}


inline
ATermAppl initConstructRegTransOrNil(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunRegTransOrNil(), reinterpret_cast<ATerm>(constructRegFrm()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructRegTransOrNil()
{
  static ATermAppl t = initConstructRegTransOrNil(t);
  return t;
}


inline
ATermAppl initConstructGlobVarSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunGlobVarSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructGlobVarSpec()
{
  static ATermAppl t = initConstructGlobVarSpec(t);
  return t;
}


inline
ATermAppl initConstructActSpec(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunActSpec(), reinterpret_cast<ATerm>(constructList()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructActSpec()
{
  static ATermAppl t = initConstructActSpec(t);
  return t;
}


inline
ATermAppl initConstructId(ATermAppl& t)
{
  t = ATmakeAppl1(gsAFunId(), reinterpret_cast<ATerm>(constructString()));
  ATprotect(reinterpret_cast<ATerm*>(&t));
  return t;
}

inline
ATermAppl constructId()
{
  static ATermAppl t = initConstructId(t);
  return t;
}


inline
ATermAppl constructSortExpr()
{
  return constructSortId();
}


inline
ATermAppl constructSortConsType()
{
  return constructSortList();
}


inline
ATermAppl constructStringOrNil()
{
  return constructString();
}


inline
ATermAppl constructDataExpr()
{
  return constructId();
}


inline
ATermAppl constructBindingOperator()
{
  return constructSetBagComp();
}


inline
ATermAppl constructWhrDecl()
{
  return constructIdInit();
}


inline
ATermAppl constructSortDecl()
{
  return constructSortId();
}


inline
ATermAppl constructDataExprOrNil()
{
  return constructDataExpr();
}


inline
ATermAppl constructParamIdOrAction()
{
  return constructParamId();
}


inline
ATermAppl constructProcExpr()
{
  return constructParamId();
}


inline
ATermAppl constructMultActOrDelta()
{
  return constructMultAct();
}


inline
ATermAppl constructProcInit()
{
  return constructProcessInit();
}


inline
ATermAppl constructStateFrm()
{
  return constructDataExpr();
}


inline
ATermAppl constructRegFrm()
{
  return constructActFrm();
}


inline
ATermAppl constructActFrm()
{
  return constructMultAct();
}


inline
ATermAppl constructActionRenameRuleRHS()
{
  return constructParamId();
}


inline
ATermAppl constructFixPoint()
{
  return constructMu();
}


inline
ATermAppl constructPBExpr()
{
  return constructDataExpr();
}


inline
ATermAppl constructBooleanExpression()
{
  return constructBooleanTrue();
}



}

}

}
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/soundness_checks.h" 1
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/soundness_checks.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 1
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/soundness_checks.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 1
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/soundness_checks.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 1
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/soundness_checks.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_traits.h" 1
# 24 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/soundness_checks.h" 2


namespace mcrl2 {

namespace core {

namespace detail {



template <typename Term, typename CheckFunction>
bool check_term_argument(Term t, CheckFunction f)
{
  return f(t);
}





template <typename Term, typename CheckFunction>
bool check_list_argument(Term t, CheckFunction f, unsigned int minimum_size)
{
  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (t.type() != 4L)
    return false;
  atermpp::aterm_list l(term);
  if (l.size() < minimum_size)
    return false;
  for (atermpp::aterm_list::iterator i = l.begin(); i != l.end(); ++i)
  {
    if (!f(*i))
      return false;
  }
  return true;
}

template <typename Term>
bool check_rule_String(Term t)
{
  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (a.size() > 0)
    return false;
  return true;
}

template <typename Term>
bool check_rule_NumberString(Term t)
{
  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (a.size() > 0)
    return false;
  return true;
}


template <typename Term> bool check_rule_SortExpr(Term t);
template <typename Term> bool check_rule_SortId(Term t);
template <typename Term> bool check_rule_SortConsType(Term t);
template <typename Term> bool check_rule_StructCons(Term t);
template <typename Term> bool check_rule_StructProj(Term t);
template <typename Term> bool check_rule_StringOrNil(Term t);
template <typename Term> bool check_rule_DataExpr(Term t);
template <typename Term> bool check_rule_DataVarId(Term t);
template <typename Term> bool check_rule_OpId(Term t);
template <typename Term> bool check_rule_BindingOperator(Term t);
template <typename Term> bool check_rule_WhrDecl(Term t);
template <typename Term> bool check_rule_DataVarIdInit(Term t);
template <typename Term> bool check_rule_IdInit(Term t);
template <typename Term> bool check_rule_DataSpec(Term t);
template <typename Term> bool check_rule_SortSpec(Term t);
template <typename Term> bool check_rule_ConsSpec(Term t);
template <typename Term> bool check_rule_MapSpec(Term t);
template <typename Term> bool check_rule_DataEqnSpec(Term t);
template <typename Term> bool check_rule_SortDecl(Term t);
template <typename Term> bool check_rule_DataEqn(Term t);
template <typename Term> bool check_rule_DataExprOrNil(Term t);
template <typename Term> bool check_rule_MultAct(Term t);
template <typename Term> bool check_rule_ParamIdOrAction(Term t);
template <typename Term> bool check_rule_ParamId(Term t);
template <typename Term> bool check_rule_Action(Term t);
template <typename Term> bool check_rule_ActId(Term t);
template <typename Term> bool check_rule_ProcExpr(Term t);
template <typename Term> bool check_rule_ProcVarId(Term t);
template <typename Term> bool check_rule_MultActName(Term t);
template <typename Term> bool check_rule_RenameExpr(Term t);
template <typename Term> bool check_rule_CommExpr(Term t);
template <typename Term> bool check_rule_ProcSpec(Term t);
template <typename Term> bool check_rule_ActSpec(Term t);
template <typename Term> bool check_rule_GlobVarSpec(Term t);
template <typename Term> bool check_rule_ProcEqnSpec(Term t);
template <typename Term> bool check_rule_ProcEqn(Term t);
template <typename Term> bool check_rule_MultActOrDelta(Term t);
template <typename Term> bool check_rule_ProcInit(Term t);
template <typename Term> bool check_rule_LinProcSpec(Term t);
template <typename Term> bool check_rule_LinearProcess(Term t);
template <typename Term> bool check_rule_LinearProcessSummand(Term t);
template <typename Term> bool check_rule_LinearProcessInit(Term t);
template <typename Term> bool check_rule_StateFrm(Term t);
template <typename Term> bool check_rule_RegFrm(Term t);
template <typename Term> bool check_rule_ActFrm(Term t);
template <typename Term> bool check_rule_ActionRenameRules(Term t);
template <typename Term> bool check_rule_ActionRenameRule(Term t);
template <typename Term> bool check_rule_ActionRenameRuleRHS(Term t);
template <typename Term> bool check_rule_ActionRenameSpec(Term t);
template <typename Term> bool check_rule_PBES(Term t);
template <typename Term> bool check_rule_PBEqnSpec(Term t);
template <typename Term> bool check_rule_PBInit(Term t);
template <typename Term> bool check_rule_PBEqn(Term t);
template <typename Term> bool check_rule_FixPoint(Term t);
template <typename Term> bool check_rule_PropVarDecl(Term t);
template <typename Term> bool check_rule_PBExpr(Term t);
template <typename Term> bool check_rule_PropVarInst(Term t);
template <typename Term> bool check_rule_BES(Term t);
template <typename Term> bool check_rule_BooleanEquation(Term t);
template <typename Term> bool check_rule_BooleanVariable(Term t);
template <typename Term> bool check_rule_BooleanExpression(Term t);
template <typename Term> bool check_term_BooleanOr(Term t);
template <typename Term> bool check_term_StateOr(Term t);
template <typename Term> bool check_term_Hide(Term t);
template <typename Term> bool check_term_SortArrow(Term t);
template <typename Term> bool check_term_ProcessAssignment(Term t);
template <typename Term> bool check_term_Forall(Term t);
template <typename Term> bool check_term_CommExpr(Term t);
template <typename Term> bool check_term_StateNot(Term t);
template <typename Term> bool check_term_BooleanFalse(Term t);
template <typename Term> bool check_term_SortFSet(Term t);
template <typename Term> bool check_term_StateImp(Term t);
template <typename Term> bool check_term_PBESExists(Term t);
template <typename Term> bool check_term_PBESImp(Term t);
template <typename Term> bool check_term_Binder(Term t);
template <typename Term> bool check_term_SortsPossible(Term t);
template <typename Term> bool check_term_SortRef(Term t);
template <typename Term> bool check_term_ProcEqnSpec(Term t);
template <typename Term> bool check_term_StateForall(Term t);
template <typename Term> bool check_term_BooleanImp(Term t);
template <typename Term> bool check_term_SortId(Term t);
template <typename Term> bool check_term_StateNu(Term t);
template <typename Term> bool check_term_RegNil(Term t);
template <typename Term> bool check_term_DataSpec(Term t);
template <typename Term> bool check_term_Tau(Term t);
template <typename Term> bool check_term_StateYaledTimed(Term t);
template <typename Term> bool check_term_SortCons(Term t);
template <typename Term> bool check_term_DataEqnSpec(Term t);
template <typename Term> bool check_term_LinearProcessSummand(Term t);
template <typename Term> bool check_term_SortSpec(Term t);
template <typename Term> bool check_term_ActionRenameRules(Term t);
template <typename Term> bool check_term_BooleanEquation(Term t);
template <typename Term> bool check_term_ConsSpec(Term t);
template <typename Term> bool check_term_SortList(Term t);
template <typename Term> bool check_term_Sum(Term t);
template <typename Term> bool check_term_DataVarId(Term t);
template <typename Term> bool check_term_ProcVarId(Term t);
template <typename Term> bool check_term_ProcessInit(Term t);
template <typename Term> bool check_term_BES(Term t);
template <typename Term> bool check_term_MapSpec(Term t);
template <typename Term> bool check_term_StateYaled(Term t);
template <typename Term> bool check_term_BooleanAnd(Term t);
template <typename Term> bool check_term_LinProcSpec(Term t);
template <typename Term> bool check_term_SetBagComp(Term t);
template <typename Term> bool check_term_Choice(Term t);
template <typename Term> bool check_term_LinearProcessInit(Term t);
template <typename Term> bool check_term_MultAct(Term t);
template <typename Term> bool check_term_PropVarInst(Term t);
template <typename Term> bool check_term_BagComp(Term t);
template <typename Term> bool check_term_StateDelay(Term t);
template <typename Term> bool check_term_IdAssignment(Term t);
template <typename Term> bool check_term_RegAlt(Term t);
template <typename Term> bool check_term_StructCons(Term t);
template <typename Term> bool check_term_IdInit(Term t);
template <typename Term> bool check_term_Mu(Term t);
template <typename Term> bool check_term_PBEqnSpec(Term t);
template <typename Term> bool check_term_ActNot(Term t);
template <typename Term> bool check_term_BooleanTrue(Term t);
template <typename Term> bool check_term_Block(Term t);
template <typename Term> bool check_term_Rename(Term t);
template <typename Term> bool check_term_Exists(Term t);
template <typename Term> bool check_term_Sync(Term t);
template <typename Term> bool check_term_ActExists(Term t);
template <typename Term> bool check_term_ProcSpec(Term t);
template <typename Term> bool check_term_StateMu(Term t);
template <typename Term> bool check_term_StateFalse(Term t);
template <typename Term> bool check_term_PBESForall(Term t);
template <typename Term> bool check_term_StateTrue(Term t);
template <typename Term> bool check_term_BInit(Term t);
template <typename Term> bool check_term_PBESFalse(Term t);
template <typename Term> bool check_term_DataAppl(Term t);
template <typename Term> bool check_term_RegTrans(Term t);
template <typename Term> bool check_term_StateDelayTimed(Term t);
template <typename Term> bool check_term_Nu(Term t);
template <typename Term> bool check_term_SortStruct(Term t);
template <typename Term> bool check_term_AtTime(Term t);
template <typename Term> bool check_term_ActOr(Term t);
template <typename Term> bool check_term_Comm(Term t);
template <typename Term> bool check_term_BooleanNot(Term t);
template <typename Term> bool check_term_Delta(Term t);
template <typename Term> bool check_term_StateAnd(Term t);
template <typename Term> bool check_term_LMerge(Term t);
template <typename Term> bool check_term_SetComp(Term t);
template <typename Term> bool check_term_ActForall(Term t);
template <typename Term> bool check_term_RenameExpr(Term t);
template <typename Term> bool check_term_Merge(Term t);
template <typename Term> bool check_term_IfThen(Term t);
template <typename Term> bool check_term_BooleanVariable(Term t);
template <typename Term> bool check_term_Action(Term t);
template <typename Term> bool check_term_PBESAnd(Term t);
template <typename Term> bool check_term_Lambda(Term t);
template <typename Term> bool check_term_StateMust(Term t);
template <typename Term> bool check_term_Seq(Term t);
template <typename Term> bool check_term_DataVarIdInit(Term t);
template <typename Term> bool check_term_Process(Term t);
template <typename Term> bool check_term_ActAnd(Term t);
template <typename Term> bool check_term_ActionRenameSpec(Term t);
template <typename Term> bool check_term_PBES(Term t);
template <typename Term> bool check_term_StateVar(Term t);
template <typename Term> bool check_term_ActionRenameRule(Term t);
template <typename Term> bool check_term_LinearProcess(Term t);
template <typename Term> bool check_term_ActAt(Term t);
template <typename Term> bool check_term_DataEqn(Term t);
template <typename Term> bool check_term_PBESNot(Term t);
template <typename Term> bool check_term_StateExists(Term t);
template <typename Term> bool check_term_StateMay(Term t);
template <typename Term> bool check_term_ParamId(Term t);
template <typename Term> bool check_term_PBESTrue(Term t);
template <typename Term> bool check_term_MultActName(Term t);
template <typename Term> bool check_term_IfThenElse(Term t);
template <typename Term> bool check_term_Nil(Term t);
template <typename Term> bool check_term_ProcEqn(Term t);
template <typename Term> bool check_term_StructProj(Term t);
template <typename Term> bool check_term_PBEqn(Term t);
template <typename Term> bool check_term_Whr(Term t);
template <typename Term> bool check_term_OpId(Term t);
template <typename Term> bool check_term_SortSet(Term t);
template <typename Term> bool check_term_ActFalse(Term t);
template <typename Term> bool check_term_ActId(Term t);
template <typename Term> bool check_term_SortUnknown(Term t);
template <typename Term> bool check_term_PBESOr(Term t);
template <typename Term> bool check_term_RegSeq(Term t);
template <typename Term> bool check_term_SortFBag(Term t);
template <typename Term> bool check_term_Allow(Term t);
template <typename Term> bool check_term_PropVarDecl(Term t);
template <typename Term> bool check_term_ActImp(Term t);
template <typename Term> bool check_term_SortBag(Term t);
template <typename Term> bool check_term_PBInit(Term t);
template <typename Term> bool check_term_ActTrue(Term t);
template <typename Term> bool check_term_RegTransOrNil(Term t);
template <typename Term> bool check_term_GlobVarSpec(Term t);
template <typename Term> bool check_term_ActSpec(Term t);
template <typename Term> bool check_term_Id(Term t);

template <typename Term>
bool check_rule_SortExpr(Term t)
{

  return check_rule_SortId(t)
         || check_term_SortCons(t)
         || check_term_SortStruct(t)
         || check_term_SortArrow(t)
         || check_term_SortUnknown(t)
         || check_term_SortsPossible(t);



}

template <typename Term>
bool check_rule_SortId(Term t)
{

  return check_term_SortId(t);



}

template <typename Term>
bool check_rule_SortConsType(Term t)
{

  return check_term_SortList(t)
         || check_term_SortSet(t)
         || check_term_SortBag(t)
         || check_term_SortFSet(t)
         || check_term_SortFBag(t);



}

template <typename Term>
bool check_rule_StructCons(Term t)
{

  return check_term_StructCons(t);



}

template <typename Term>
bool check_rule_StructProj(Term t)
{

  return check_term_StructProj(t);



}

template <typename Term>
bool check_rule_StringOrNil(Term t)
{

  return check_rule_String(t)
         || check_term_Nil(t);



}

template <typename Term>
bool check_rule_DataExpr(Term t)
{

  return check_term_Id(t)
         || check_rule_DataVarId(t)
         || check_rule_OpId(t)
         || check_term_DataAppl(t)
         || check_term_Binder(t)
         || check_term_Whr(t);



}

template <typename Term>
bool check_rule_DataVarId(Term t)
{

  return check_term_DataVarId(t);



}

template <typename Term>
bool check_rule_OpId(Term t)
{

  return check_term_OpId(t);



}

template <typename Term>
bool check_rule_BindingOperator(Term t)
{

  return check_term_SetBagComp(t)
         || check_term_SetComp(t)
         || check_term_BagComp(t)
         || check_term_Forall(t)
         || check_term_Exists(t)
         || check_term_Lambda(t);



}

template <typename Term>
bool check_rule_WhrDecl(Term t)
{

  return check_rule_IdInit(t)
         || check_rule_DataVarIdInit(t);



}

template <typename Term>
bool check_rule_DataVarIdInit(Term t)
{

  return check_term_DataVarIdInit(t);



}

template <typename Term>
bool check_rule_IdInit(Term t)
{

  return check_term_IdInit(t);



}

template <typename Term>
bool check_rule_DataSpec(Term t)
{

  return check_term_DataSpec(t);



}

template <typename Term>
bool check_rule_SortSpec(Term t)
{

  return check_term_SortSpec(t);



}

template <typename Term>
bool check_rule_ConsSpec(Term t)
{

  return check_term_ConsSpec(t);



}

template <typename Term>
bool check_rule_MapSpec(Term t)
{

  return check_term_MapSpec(t);



}

template <typename Term>
bool check_rule_DataEqnSpec(Term t)
{

  return check_term_DataEqnSpec(t);



}

template <typename Term>
bool check_rule_SortDecl(Term t)
{

  return check_rule_SortId(t)
         || check_term_SortRef(t);



}

template <typename Term>
bool check_rule_DataEqn(Term t)
{

  return check_term_DataEqn(t);



}

template <typename Term>
bool check_rule_DataExprOrNil(Term t)
{

  return check_rule_DataExpr(t)
         || check_term_Nil(t);



}

template <typename Term>
bool check_rule_MultAct(Term t)
{

  return check_term_MultAct(t);



}

template <typename Term>
bool check_rule_ParamIdOrAction(Term t)
{

  return check_rule_ParamId(t)
         || check_rule_Action(t);



}

template <typename Term>
bool check_rule_ParamId(Term t)
{

  return check_term_ParamId(t);



}

template <typename Term>
bool check_rule_Action(Term t)
{

  return check_term_Action(t);



}

template <typename Term>
bool check_rule_ActId(Term t)
{

  return check_term_ActId(t);



}

template <typename Term>
bool check_rule_ProcExpr(Term t)
{

  return check_rule_ParamId(t)
         || check_term_IdAssignment(t)
         || check_rule_Action(t)
         || check_term_Process(t)
         || check_term_ProcessAssignment(t)
         || check_term_Delta(t)
         || check_term_Tau(t)
         || check_term_Sum(t)
         || check_term_Block(t)
         || check_term_Hide(t)
         || check_term_Rename(t)
         || check_term_Comm(t)
         || check_term_Allow(t)
         || check_term_Sync(t)
         || check_term_AtTime(t)
         || check_term_Seq(t)
         || check_term_IfThen(t)
         || check_term_IfThenElse(t)
         || check_term_BInit(t)
         || check_term_Merge(t)
         || check_term_LMerge(t)
         || check_term_Choice(t);



}

template <typename Term>
bool check_rule_ProcVarId(Term t)
{

  return check_term_ProcVarId(t);



}

template <typename Term>
bool check_rule_MultActName(Term t)
{

  return check_term_MultActName(t);



}

template <typename Term>
bool check_rule_RenameExpr(Term t)
{

  return check_term_RenameExpr(t);



}

template <typename Term>
bool check_rule_CommExpr(Term t)
{

  return check_term_CommExpr(t);



}

template <typename Term>
bool check_rule_ProcSpec(Term t)
{

  return check_term_ProcSpec(t);



}

template <typename Term>
bool check_rule_ActSpec(Term t)
{

  return check_term_ActSpec(t);



}

template <typename Term>
bool check_rule_GlobVarSpec(Term t)
{

  return check_term_GlobVarSpec(t);



}

template <typename Term>
bool check_rule_ProcEqnSpec(Term t)
{

  return check_term_ProcEqnSpec(t);



}

template <typename Term>
bool check_rule_ProcEqn(Term t)
{

  return check_term_ProcEqn(t);



}

template <typename Term>
bool check_rule_MultActOrDelta(Term t)
{

  return check_rule_MultAct(t)
         || check_term_Delta(t);



}

template <typename Term>
bool check_rule_ProcInit(Term t)
{

  return check_term_ProcessInit(t);



}

template <typename Term>
bool check_rule_LinProcSpec(Term t)
{

  return check_term_LinProcSpec(t);



}

template <typename Term>
bool check_rule_LinearProcess(Term t)
{

  return check_term_LinearProcess(t);



}

template <typename Term>
bool check_rule_LinearProcessSummand(Term t)
{

  return check_term_LinearProcessSummand(t);



}

template <typename Term>
bool check_rule_LinearProcessInit(Term t)
{

  return check_term_LinearProcessInit(t);



}

template <typename Term>
bool check_rule_StateFrm(Term t)
{

  return check_rule_DataExpr(t)
         || check_term_StateTrue(t)
         || check_term_StateFalse(t)
         || check_term_StateNot(t)
         || check_term_StateAnd(t)
         || check_term_StateOr(t)
         || check_term_StateImp(t)
         || check_term_StateForall(t)
         || check_term_StateExists(t)
         || check_term_StateMust(t)
         || check_term_StateMay(t)
         || check_term_StateYaled(t)
         || check_term_StateYaledTimed(t)
         || check_term_StateDelay(t)
         || check_term_StateDelayTimed(t)
         || check_term_StateVar(t)
         || check_term_StateNu(t)
         || check_term_StateMu(t);



}

template <typename Term>
bool check_rule_RegFrm(Term t)
{

  return check_rule_ActFrm(t)
         || check_term_RegNil(t)
         || check_term_RegSeq(t)
         || check_term_RegAlt(t)
         || check_term_RegTrans(t)
         || check_term_RegTransOrNil(t);



}

template <typename Term>
bool check_rule_ActFrm(Term t)
{

  return check_rule_MultAct(t)
         || check_rule_DataExpr(t)
         || check_term_ActTrue(t)
         || check_term_ActFalse(t)
         || check_term_ActNot(t)
         || check_term_ActAnd(t)
         || check_term_ActOr(t)
         || check_term_ActImp(t)
         || check_term_ActForall(t)
         || check_term_ActExists(t)
         || check_term_ActAt(t);



}

template <typename Term>
bool check_rule_ActionRenameRules(Term t)
{

  return check_term_ActionRenameRules(t);



}

template <typename Term>
bool check_rule_ActionRenameRule(Term t)
{

  return check_term_ActionRenameRule(t);



}

template <typename Term>
bool check_rule_ActionRenameRuleRHS(Term t)
{

  return check_rule_ParamId(t)
         || check_rule_Action(t)
         || check_term_Delta(t)
         || check_term_Tau(t);



}

template <typename Term>
bool check_rule_ActionRenameSpec(Term t)
{

  return check_term_ActionRenameSpec(t);



}

template <typename Term>
bool check_rule_PBES(Term t)
{

  return check_term_PBES(t);



}

template <typename Term>
bool check_rule_PBEqnSpec(Term t)
{

  return check_term_PBEqnSpec(t);



}

template <typename Term>
bool check_rule_PBInit(Term t)
{

  return check_term_PBInit(t);



}

template <typename Term>
bool check_rule_PBEqn(Term t)
{

  return check_term_PBEqn(t);



}

template <typename Term>
bool check_rule_FixPoint(Term t)
{

  return check_term_Mu(t)
         || check_term_Nu(t);



}

template <typename Term>
bool check_rule_PropVarDecl(Term t)
{

  return check_term_PropVarDecl(t);



}

template <typename Term>
bool check_rule_PBExpr(Term t)
{

  return check_rule_DataExpr(t)
         || check_term_PBESTrue(t)
         || check_term_PBESFalse(t)
         || check_term_PBESNot(t)
         || check_term_PBESAnd(t)
         || check_term_PBESOr(t)
         || check_term_PBESImp(t)
         || check_term_PBESForall(t)
         || check_term_PBESExists(t)
         || check_rule_PropVarInst(t);



}

template <typename Term>
bool check_rule_PropVarInst(Term t)
{

  return check_term_PropVarInst(t);



}

template <typename Term>
bool check_rule_BES(Term t)
{

  return check_term_BES(t);



}

template <typename Term>
bool check_rule_BooleanEquation(Term t)
{

  return check_term_BooleanEquation(t);



}

template <typename Term>
bool check_rule_BooleanVariable(Term t)
{

  return check_term_BooleanVariable(t);



}

template <typename Term>
bool check_rule_BooleanExpression(Term t)
{

  return check_term_BooleanTrue(t)
         || check_term_BooleanFalse(t)
         || check_rule_BooleanVariable(t)
         || check_term_BooleanNot(t)
         || check_term_BooleanAnd(t)
         || check_term_BooleanOr(t)
         || check_term_BooleanImp(t);



}


template <typename Term>
bool check_term_BooleanOr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanOr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateOr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateOr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Hide(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsHide(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_String<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortArrow(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortArrow(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_SortExpr<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_SortExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ProcessAssignment(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcessAssignment(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcVarId<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcVarId" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataVarIdInit<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarIdInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Forall(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsForall(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_CommExpr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsCommExpr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_MultActName<atermpp::aterm>))
    {
      std::cerr << "check_rule_MultActName" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StringOrNil<atermpp::aterm>))
    {
      std::cerr << "check_rule_StringOrNil" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateNot(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateNot(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BooleanFalse(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanFalse(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_SortFSet(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortFSet(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_StateImp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateImp(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBESExists(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESExists(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBESImp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESImp(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Binder(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBinder(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_BindingOperator<atermpp::aterm>))
    {
      std::cerr << "check_rule_BindingOperator" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortsPossible(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortsPossible(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_SortExpr<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortRef(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortRef(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_SortExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ProcEqnSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcEqnSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_ProcEqn<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_ProcEqn" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateForall(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateForall(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BooleanImp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanImp(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortId(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortId(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateNu(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateNu(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataVarIdInit<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarIdInit" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_RegNil(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRegNil(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_DataSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDataSpec(a))
    return false;


  if (a.size() != 4)
    return false;

  if (!check_term_argument(a(0), check_rule_SortSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ConsSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_ConsSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_MapSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_MapSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_DataEqnSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataEqnSpec" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Tau(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsTau(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_StateYaledTimed(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateYaledTimed(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortCons(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortCons(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_SortConsType<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortConsType" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_SortExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_DataEqnSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDataEqnSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_DataEqn<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataEqn" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_LinearProcessSummand(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsLinearProcessSummand(a))
    return false;


  if (a.size() != 5)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_MultActOrDelta<atermpp::aterm>))
    {
      std::cerr << "check_rule_MultActOrDelta" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_DataExprOrNil<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExprOrNil" << std::endl;
      return false;
    }
  if (!check_list_argument(a(4), check_rule_DataVarIdInit<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarIdInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_SortDecl<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_SortDecl" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActionRenameRules(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActionRenameRules(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_ActionRenameRule<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_ActionRenameRule" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BooleanEquation(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanEquation(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_FixPoint<atermpp::aterm>))
    {
      std::cerr << "check_rule_FixPoint" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_BooleanVariable<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanVariable" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ConsSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsConsSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_OpId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_OpId" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortList(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortList(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_Sum(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSum(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_DataVarId(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDataVarId(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_SortExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ProcVarId(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcVarId(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_SortExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ProcessInit(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcessInit(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BES(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBES(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_BooleanEquation<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_BooleanEquation" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_MapSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsMapSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_OpId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_OpId" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateYaled(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateYaled(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_BooleanAnd(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanAnd(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_LinProcSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsLinProcSpec(a))
    return false;


  if (a.size() != 5)
    return false;

  if (!check_term_argument(a(0), check_rule_DataSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_GlobVarSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_GlobVarSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_LinearProcess<atermpp::aterm>))
    {
      std::cerr << "check_rule_LinearProcess" << std::endl;
      return false;
    }
  if (!check_term_argument(a(4), check_rule_LinearProcessInit<atermpp::aterm>))
    {
      std::cerr << "check_rule_LinearProcessInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SetBagComp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSetBagComp(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_Choice(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsChoice(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_LinearProcessInit(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsLinearProcessInit(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarIdInit<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarIdInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_MultAct(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsMultAct(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_ParamIdOrAction<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_ParamIdOrAction" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PropVarInst(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPropVarInst(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BagComp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBagComp(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_StateDelay(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateDelay(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_IdAssignment(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsIdAssignment(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_IdInit<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_IdInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_RegAlt(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRegAlt(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StructCons(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStructCons(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_StructProj<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_StructProj" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_StringOrNil<atermpp::aterm>))
    {
      std::cerr << "check_rule_StringOrNil" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_IdInit(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsIdInit(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Mu(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsMu(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_PBEqnSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBEqnSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_PBEqn<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_PBEqn" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActNot(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActNot(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BooleanTrue(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanTrue(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_Block(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBlock(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_String<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Rename(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRename(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_RenameExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_RenameExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Exists(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsExists(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_Sync(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSync(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActExists(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActExists(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ProcSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcSpec(a))
    return false;


  if (a.size() != 5)
    return false;

  if (!check_term_argument(a(0), check_rule_DataSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_GlobVarSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_GlobVarSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_ProcEqnSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcEqnSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(4), check_rule_ProcInit<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateMu(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateMu(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataVarIdInit<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarIdInit" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateFalse(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateFalse(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_PBESForall(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESForall(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateTrue(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateTrue(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_BInit(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBInit(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBESFalse(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESFalse(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_DataAppl(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDataAppl(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataExpr<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_RegTrans(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRegTrans(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateDelayTimed(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateDelayTimed(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Nu(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsNu(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_SortStruct(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortStruct(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_StructCons<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_StructCons" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_AtTime(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsAtTime(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActOr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActOr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Comm(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsComm(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_CommExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_CommExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BooleanNot(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanNot(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_BooleanExpression<atermpp::aterm>))
    {
      std::cerr << "check_rule_BooleanExpression" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Delta(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDelta(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_StateAnd(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateAnd(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_LMerge(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsLMerge(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SetComp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSetComp(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_ActForall(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActForall(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_RenameExpr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRenameExpr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Merge(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsMerge(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_IfThen(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsIfThen(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_BooleanVariable(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsBooleanVariable(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Action(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsAction(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ActId<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActId" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBESAnd(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESAnd(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Lambda(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsLambda(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_StateMust(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateMust(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Seq(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSeq(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_DataVarIdInit(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDataVarIdInit(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_DataVarId<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Process(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcess(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcVarId<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcVarId" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActAnd(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActAnd(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActionRenameSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActionRenameSpec(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_DataSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_ActionRenameRules<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActionRenameRules" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBES(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBES(a))
    return false;


  if (a.size() != 4)
    return false;

  if (!check_term_argument(a(0), check_rule_DataSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_GlobVarSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_GlobVarSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_PBEqnSpec<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBEqnSpec" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_PBInit<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBInit" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateVar(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateVar(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActionRenameRule(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActionRenameRule(a))
    return false;


  if (a.size() != 4)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_ParamIdOrAction<atermpp::aterm>))
    {
      std::cerr << "check_rule_ParamIdOrAction" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_ActionRenameRuleRHS<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActionRenameRuleRHS" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_LinearProcess(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsLinearProcess(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_LinearProcessSummand<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_LinearProcessSummand" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActAt(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActAt(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_DataEqn(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsDataEqn(a))
    return false;


  if (a.size() != 4)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(3), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBESNot(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESNot(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateExists(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateExists(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StateMay(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStateMay(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_StateFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_StateFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ParamId(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsParamId(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBESTrue(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESTrue(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_MultActName(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsMultActName(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_String<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_IfThenElse(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsIfThenElse(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Nil(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsNil(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_ProcEqn(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsProcEqn(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_ProcVarId<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcVarId" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_StructProj(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsStructProj(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_StringOrNil<atermpp::aterm>))
    {
      std::cerr << "check_rule_StringOrNil" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_SortExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PBEqn(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBEqn(a))
    return false;


  if (a.size() != 3)
    return false;

  if (!check_term_argument(a(0), check_rule_FixPoint<atermpp::aterm>))
    {
      std::cerr << "check_rule_FixPoint" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_PropVarDecl<atermpp::aterm>))
    {
      std::cerr << "check_rule_PropVarDecl" << std::endl;
      return false;
    }
  if (!check_term_argument(a(2), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Whr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsWhr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_DataExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_DataExpr" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_WhrDecl<atermpp::aterm>, 1))
    {
      std::cerr << "check_rule_WhrDecl" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_OpId(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsOpId(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_SortExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortSet(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortSet(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_ActFalse(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActFalse(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_ActId(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActId(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_SortExpr<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_SortExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortUnknown(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortUnknown(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_PBESOr(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBESOr(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_PBExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_PBExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_RegSeq(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRegSeq(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortFBag(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortFBag(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_Allow(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsAllow(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_list_argument(a(0), check_rule_MultActName<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_MultActName" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ProcExpr<atermpp::aterm>))
    {
      std::cerr << "check_rule_ProcExpr" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_PropVarDecl(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPropVarDecl(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }
  if (!check_list_argument(a(1), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActImp(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActImp(a))
    return false;


  if (a.size() != 2)
    return false;

  if (!check_term_argument(a(0), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }
  if (!check_term_argument(a(1), check_rule_ActFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_ActFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_SortBag(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsSortBag(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_PBInit(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsPBInit(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_PropVarInst<atermpp::aterm>))
    {
      std::cerr << "check_rule_PropVarInst" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActTrue(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActTrue(a))
    return false;


  if (a.size() != 0)
    return false;


  return true;
}


template <typename Term>
bool check_term_RegTransOrNil(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsRegTransOrNil(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_RegFrm<atermpp::aterm>))
    {
      std::cerr << "check_rule_RegFrm" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_GlobVarSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsGlobVarSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_DataVarId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_DataVarId" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_ActSpec(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsActSpec(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_list_argument(a(0), check_rule_ActId<atermpp::aterm>, 0))
    {
      std::cerr << "check_rule_ActId" << std::endl;
      return false;
    }



  return true;
}


template <typename Term>
bool check_term_Id(Term t)
{


  atermpp::aterm term(atermpp::aterm_traits<Term>::term(t));
  if (term.type() != 1L)
    return false;
  atermpp::aterm_appl a(term);
  if (!gsIsId(a))
    return false;


  if (a.size() != 1)
    return false;

  if (!check_term_argument(a(0), check_rule_String<atermpp::aterm>))
    {
      std::cerr << "check_rule_String" << std::endl;
      return false;
    }



  return true;
}


}

}

}
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/identifier_string.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/identifier_string.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/utility.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/utility.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm.h" 1
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/utility.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/utility.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/utility.h" 2

namespace atermpp {

  namespace detail {




    inline
    ATermAppl str2appl(std::string const& s)
    {
      return ATmakeAppl0(ATmakeAFun(s.c_str(), 0, ATtrue));
    }

  }

}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/utility.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/utility.h"
namespace atermpp
{




  inline
  aterm make_term(const std::string& pattern)
  {
    return aterm(ATreadFromString(const_cast<char*>(pattern.c_str())));
  }

}
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h" 2

namespace atermpp
{
  using detail::str2appl;


  class aterm_string: public aterm_appl
  {
    public:

      aterm_string()
      {}



      aterm_string(ATermAppl t)
        : aterm_appl(t)
      {
        ((aterm_appl(t).size() == 0) ? static_cast<void> (0) : __assert_fail ("aterm_appl(t).size() == 0", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 38, __PRETTY_FUNCTION__));
      }



      aterm_string(aterm_appl t)
        : aterm_appl(t)
      {
        ((t.size() == 0) ? static_cast<void> (0) : __assert_fail ("t.size() == 0", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 46, __PRETTY_FUNCTION__));
      }
# 71 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h"
      aterm_string(std::string const& s, bool quoted = true)
        : aterm_appl(quoted ? str2appl(s) : make_term(s))
      {
        ((type() == 1L) ? static_cast<void> (0) : __assert_fail ("type() == 1L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 74, __PRETTY_FUNCTION__));
        ((aterm_appl(m_term).size() == 0) ? static_cast<void> (0) : __assert_fail ("aterm_appl(m_term).size() == 0", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 75, __PRETTY_FUNCTION__));
      }



      aterm_string& operator=(aterm_base t)
      {
        ((t.type() == 1L) ? static_cast<void> (0) : __assert_fail ("t.type() == 1L", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 82, __PRETTY_FUNCTION__));
        ((aterm_appl(t).size() == 0) ? static_cast<void> (0) : __assert_fail ("aterm_appl(t).size() == 0", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 83, __PRETTY_FUNCTION__));
        m_term = aterm_traits<aterm_base>::term(t);
        return *this;
      }



      operator std::string() const
      {
        return function().name();
      }



      bool operator==(char const* const other) const
      {
        return std::string(function().name()) == other;
      }
  };




  inline
  std::string unquote(aterm_string t)
  {
    std::string s(t);
    ((s.size() >= 2 && *s.begin() == '"' && *s.rbegin() == '"') ? static_cast<void> (0) : __assert_fail ("s.size() >= 2 && *s.begin() == '\"' && *s.rbegin() == '\"'", "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_string.h", 110, __PRETTY_FUNCTION__));
    return std::string(s, 1, s.size() - 2);
  }


  template <>
  struct aterm_traits<aterm_string>
  {
    typedef ATermAppl aterm_type;
    static void protect(aterm_string t) { t.protect(); }
    static void unprotect(aterm_string t) { t.unprotect(); }
    static void mark(aterm_string t) { t.mark(); }
    static ATerm term(aterm_string t) { return t.term(); }
    static ATerm* ptr(aterm_string& t) { return &t.term(); }
  };


}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/identifier_string.h" 2

namespace mcrl2 {

namespace core {



  typedef atermpp::aterm_string identifier_string;




  inline
  bool is_identifier_string(atermpp::aterm t)
  {
    return t.type() == 1L && atermpp::aterm_appl(t).size() == 0;
  }


  typedef atermpp::term_list<identifier_string> identifier_string_list;

}

}
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/struct_core.h" 1
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h"
# 1 "/usr/include/boost/range/iterator_range.hpp" 1 3 4
# 31 "/usr/include/boost/range/iterator_range.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 36 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost/assert.hpp" 2 3 4
# 32 "/usr/include/boost/range/iterator_range.hpp" 2 3 4


# 1 "/usr/include/boost/range/functions.hpp" 1 3 4
# 18 "/usr/include/boost/range/functions.hpp" 3 4
# 1 "/usr/include/boost/range/begin.hpp" 1 3 4
# 18 "/usr/include/boost/range/begin.hpp" 3 4
# 1 "/usr/include/boost/range/config.hpp" 1 3 4
# 19 "/usr/include/boost/range/begin.hpp" 2 3 4





# 1 "/usr/include/boost/range/iterator.hpp" 1 3 4
# 19 "/usr/include/boost/range/iterator.hpp" 3 4
# 1 "/usr/include/boost/range/mutable_iterator.hpp" 1 3 4
# 28 "/usr/include/boost/range/mutable_iterator.hpp" 3 4
namespace boost
{




    template< typename C >
    struct range_mutable_iterator
    {
        typedef typename C::iterator type;
    };





    template< typename Iterator >
    struct range_mutable_iterator< std::pair<Iterator,Iterator> >
    {
        typedef Iterator type;
    };





    template< typename T, std::size_t sz >
    struct range_mutable_iterator< T[sz] >
    {
        typedef T* type;
    };

}
# 20 "/usr/include/boost/range/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/range/const_iterator.hpp" 1 3 4
# 28 "/usr/include/boost/range/const_iterator.hpp" 3 4
namespace boost
{




    template< typename C >
    struct range_const_iterator
    {
        typedef typename C::const_iterator type;
    };





    template< typename Iterator >
    struct range_const_iterator< std::pair<Iterator,Iterator> >
    {
        typedef Iterator type;
    };





    template< typename T, std::size_t sz >
    struct range_const_iterator< T[sz] >
    {
        typedef const T* type;
    };

}
# 21 "/usr/include/boost/range/iterator.hpp" 2 3 4




namespace boost
{
# 50 "/usr/include/boost/range/iterator.hpp" 3 4
    template< typename C >
    struct range_iterator
    {







        typedef typename
            mpl::eval_if_c< is_const<C>::value,
                            range_const_iterator< typename remove_const<C>::type >,
                            range_mutable_iterator<C> >::type type;


    };

}
# 25 "/usr/include/boost/range/begin.hpp" 2 3 4

namespace boost
{




namespace range_detail
{






    template< typename C >
    inline typename range_iterator<C>::type
    range_begin( C& c )
    {





        return c.begin();
    }





    template< typename Iterator >
    inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }

    template< typename Iterator >
    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }
# 75 "/usr/include/boost/range/begin.hpp" 3 4
    template< typename T, std::size_t sz >
    inline const T* range_begin( const T (&a)[sz] )
    {
        return a;
    }

    template< typename T, std::size_t sz >
    inline T* range_begin( T (&a)[sz] )
    {
        return a;
    }





}



template< class T >
inline typename range_iterator<T>::type begin( T& r )
{



    using namespace range_detail;

    return range_begin( r );
}

template< class T >
inline typename range_iterator<const T>::type begin( const T& r )
{



    using namespace range_detail;

    return range_begin( r );
}

}



namespace boost
{
    template< class T >
    inline typename range_iterator<const T>::type
    const_begin( const T& r )
    {
        return boost::begin( r );
    }
}
# 19 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/end.hpp" 1 3 4
# 24 "/usr/include/boost/range/end.hpp" 3 4
# 1 "/usr/include/boost/range/detail/implementation_help.hpp" 1 3 4
# 15 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
# 1 "/usr/include/boost/range/detail/common.hpp" 1 3 4
# 19 "/usr/include/boost/range/detail/common.hpp" 3 4
# 1 "/usr/include/boost/range/detail/sfinae.hpp" 1 3 4
# 20 "/usr/include/boost/range/detail/sfinae.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
        using type_traits::yes_type;
        using type_traits::no_type;





        yes_type is_string_impl( const char* const );
        yes_type is_string_impl( const wchar_t* const );
        no_type is_string_impl( ... );

        template< std::size_t sz >
        yes_type is_char_array_impl( char (&boost_range_array)[sz] );
        template< std::size_t sz >
        yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
        no_type is_char_array_impl( ... );

        template< std::size_t sz >
        yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
        template< std::size_t sz >
        yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
        no_type is_wchar_t_array_impl( ... );

        yes_type is_char_ptr_impl( char* const );
        no_type is_char_ptr_impl( ... );

        yes_type is_const_char_ptr_impl( const char* const );
        no_type is_const_char_ptr_impl( ... );

        yes_type is_wchar_t_ptr_impl( wchar_t* const );
        no_type is_wchar_t_ptr_impl( ... );

        yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
        no_type is_const_wchar_t_ptr_impl( ... );





        template< typename Iterator >
        yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
        no_type is_pair_impl( ... );





        struct char_or_wchar_t_array_tag {};

    }

}
# 20 "/usr/include/boost/range/detail/common.hpp" 2 3 4
# 30 "/usr/include/boost/range/detail/common.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
# 47 "/usr/include/boost/range/detail/common.hpp" 3 4
        typedef mpl::int_<1>::type std_container_;
        typedef mpl::int_<2>::type std_pair_;
        typedef mpl::int_<3>::type const_std_pair_;
        typedef mpl::int_<4>::type array_;
        typedef mpl::int_<5>::type const_array_;
        typedef mpl::int_<6>::type char_array_;
        typedef mpl::int_<7>::type wchar_t_array_;
        typedef mpl::int_<8>::type char_ptr_;
        typedef mpl::int_<9>::type const_char_ptr_;
        typedef mpl::int_<10>::type wchar_t_ptr_;
        typedef mpl::int_<11>::type const_wchar_t_ptr_;
        typedef mpl::int_<12>::type string_;

        template< typename C >
        struct range_helper
        {
            static C* c;
            static C ptr;

            static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
            static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value );
            static const bool is_array_ = boost::is_array<C>::value;

        };

        template< typename C >
        class range
        {
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
                                                                  boost::range_detail::std_pair_,
                                                                  void >::type pair_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
                                                                    boost::range_detail::array_,
                                                                    pair_t >::type array_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
                                                                    boost::range_detail::string_,
                                                                    array_t >::type string_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
                                                                    boost::range_detail::const_char_ptr_,
                                                                    string_t >::type const_char_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
                                                                    boost::range_detail::char_ptr_,
                                                                    const_char_ptr_t >::type char_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
                                                                    boost::range_detail::const_wchar_t_ptr_,
                                                                    char_ptr_t >::type const_wchar_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
                                                                    boost::range_detail::wchar_t_ptr_,
                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
                                                                    boost::range_detail::wchar_t_array_,
                                                                    wchar_ptr_t >::type wchar_array_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
                                                                    boost::range_detail::char_array_,
                                                                    wchar_array_t >::type char_array_t;
        public:
            typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
                                                                    boost::range_detail::std_container_,
                                                                    char_array_t >::type type;
        };
    }
}
# 16 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4





# 1 "/usr/include/wchar.h" 1 3 4
# 22 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4


namespace boost
{
    namespace range_detail
    {
        template <typename T>
        inline void boost_range_silence_warning( const T& ) { }





        inline const char* str_end( const char* s, const char* )
        {
            return s + strlen( s );
        }


        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
        {
            return s + wcslen( s );
        }
# 56 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
        template< class Char >
        inline Char* str_end( Char* s )
        {
            return const_cast<Char*>( str_end( s, s ) );
        }

        template< class T, std::size_t sz >
        inline T* array_end( T (&boost_range_array)[sz] )
        {
            return boost_range_array + sz;
        }

        template< class T, std::size_t sz >
        inline const T* array_end( const T (&boost_range_array)[sz] )
        {
            return boost_range_array + sz;
        }





        template< class Char >
        inline std::size_t str_size( const Char* const& s )
        {
            return str_end( s ) - s;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( const T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

    }

}
# 25 "/usr/include/boost/range/end.hpp" 2 3 4



namespace boost
{




namespace range_detail
{





        template< typename C >
        inline typename range_iterator<C>::type
        range_end( C& c )
        {





            return c.end();
        }





        template< typename Iterator >
        inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }

        template< typename Iterator >
        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }





        template< typename T, std::size_t sz >
        inline const T* range_end( const T (&a)[sz] )
        {
            return range_detail::array_end<T,sz>( a );
        }

        template< typename T, std::size_t sz >
        inline T* range_end( T (&a)[sz] )
        {
            return range_detail::array_end<T,sz>( a );
        }




}


template< class T >
inline typename range_iterator<T>::type end( T& r )
{



    using namespace range_detail;

    return range_end( r );
}

template< class T >
inline typename range_iterator<const T>::type end( const T& r )
{



    using namespace range_detail;

    return range_end( r );
}

}






namespace boost
{
    template< class T >
    inline typename range_iterator<const T>::type
    const_end( const T& r )
    {
        return boost::end( r );
    }
}
# 20 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/size.hpp" 1 3 4
# 20 "/usr/include/boost/range/size.hpp" 3 4
# 1 "/usr/include/boost/range/difference_type.hpp" 1 3 4
# 22 "/usr/include/boost/range/difference_type.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_difference : iterator_difference< typename range_iterator<T>::type >
    { };
}
# 21 "/usr/include/boost/range/size.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 36 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost/assert.hpp" 2 3 4
# 22 "/usr/include/boost/range/size.hpp" 2 3 4

namespace boost
{

    template< class T >
    inline typename range_difference<T>::type size( const T& r )
    {
        (((boost::end( r ) - boost::begin( r )) >= 0 && "reachability invariant broken!") ? static_cast<void> (0) : __assert_fail ("(boost::end( r ) - boost::begin( r )) >= 0 && \"reachability invariant broken!\"", "/usr/include/boost/range/size.hpp", 30, __PRETTY_FUNCTION__));

        return boost::end( r ) - boost::begin( r );
    }

}
# 21 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/distance.hpp" 1 3 4
# 22 "/usr/include/boost/range/distance.hpp" 3 4
namespace boost
{

    template< class T >
    inline typename range_difference<T>::type
    distance( const T& r )
    {
        return std::distance( boost::begin( r ), boost::end( r ) );
    }

}
# 22 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/empty.hpp" 1 3 4
# 22 "/usr/include/boost/range/empty.hpp" 3 4
namespace boost
{

    template< class T >
    inline bool empty( const T& r )
    {
        return boost::begin( r ) == boost::end( r );
    }

}
# 23 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/rbegin.hpp" 1 3 4
# 19 "/usr/include/boost/range/rbegin.hpp" 3 4
# 1 "/usr/include/boost/range/reverse_iterator.hpp" 1 3 4
# 20 "/usr/include/boost/range/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/iterator/reverse_iterator.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/utility.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_adaptor.hpp" 1 3 4
# 36 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 37 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4



namespace boost
{



  struct use_default;





  template<class To>
  struct is_convertible<use_default,To>
    : mpl::false_ {};


  namespace detail
  {
# 66 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
    struct enable_type;
  }
# 148 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
  template<typename From, typename To>
  struct enable_if_convertible
    : iterators::enable_if<
          is_convertible<From, To>
        , boost::detail::enable_type
      >
  {};






  namespace detail
  {


    template <class T, class DefaultNullaryFn>
    struct ia_dflt_help
      : mpl::eval_if<
            is_same<T, use_default>
          , DefaultNullaryFn
          , mpl::identity<T>
        >
    {
    };



    template <
        class Derived
      , class Base
      , class Value
      , class Traversal
      , class Reference
      , class Difference
    >
    struct iterator_adaptor_base
    {
        typedef iterator_facade<
            Derived


          , typename boost::detail::ia_dflt_help<
                Value
              , mpl::eval_if<
                    is_same<Reference,use_default>
                  , iterator_value<Base>
                  , remove_reference<Reference>
                >
            >::type






          , typename boost::detail::ia_dflt_help<
                Traversal
              , iterator_traversal<Base>
            >::type

          , typename boost::detail::ia_dflt_help<
                Reference
              , mpl::eval_if<
                    is_same<Value,use_default>
                  , iterator_reference<Base>
                  , add_reference<Value>
                >
            >::type

          , typename boost::detail::ia_dflt_help<
                Difference, iterator_difference<Base>
            >::type
        >
        type;
    };


    template <class Tr1, class Tr2>
    inline void iterator_adaptor_assert_traversal ()
    {
      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Tr1, Tr2>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_230;
    }
  }
# 259 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
  template <
      class Derived
    , class Base
    , class Value = use_default
    , class Traversal = use_default
    , class Reference = use_default
    , class Difference = use_default
  >
  class iterator_adaptor
    : public boost::detail::iterator_adaptor_base<
        Derived, Base, Value, Traversal, Reference, Difference
      >::type
  {
      friend class iterator_core_access;

   protected:
      typedef typename boost::detail::iterator_adaptor_base<
          Derived, Base, Value, Traversal, Reference, Difference
      >::type super_t;
   public:
      iterator_adaptor() {}

      explicit iterator_adaptor(Base const &iter)
          : m_iterator(iter)
      {
      }

      typedef Base base_type;

      Base const& base() const
        { return m_iterator; }

   protected:

      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;




      Base const& base_reference() const
        { return m_iterator; }

      Base& base_reference()
        { return m_iterator; }

   private:






      typename super_t::reference dereference() const
        { return *m_iterator; }

      template <
      class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
      {




          return m_iterator == x.base();
      }

      typedef typename iterator_category_to_traversal<
          typename super_t::iterator_category
      >::type my_traversal;




      void advance(typename super_t::difference_type n)
      {
          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
          m_iterator += n;
      }

      void increment() { ++m_iterator; }

      void decrement()
      {
          boost::detail::iterator_adaptor_assert_traversal<my_traversal, bidirectional_traversal_tag>();
           --m_iterator;
      }

      template <
          class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      typename super_t::difference_type distance_to(
          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
      {
          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();




          return y.base() - m_iterator;
      }



   private:
      Base m_iterator;
  };

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 370 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
# 13 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4

namespace boost
{




  template <class Iterator>
  class reverse_iterator
      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
  {
      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;

      friend class iterator_core_access;

   public:
      reverse_iterator() {}

      explicit reverse_iterator(Iterator x)
          : super_t(x) {}

      template<class OtherIterator>
      reverse_iterator(
          reverse_iterator<OtherIterator> const& r
          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
          )
          : super_t(r.base())
      {}

   private:
      typename super_t::reference dereference() const { return *boost::prior(this->base()); }

      void increment() { --this->base_reference(); }
      void decrement() { ++this->base_reference(); }

      void advance(typename super_t::difference_type n)
      {
          this->base_reference() += -n;
      }

      template <class OtherIterator>
      typename super_t::difference_type
      distance_to(reverse_iterator<OtherIterator> const& y) const
      {
          return this->base_reference() - y.base();
      }
  };

  template <class BidirectionalIterator>
  reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
  {
      return reverse_iterator<BidirectionalIterator>(x);
  }

}
# 21 "/usr/include/boost/range/reverse_iterator.hpp" 2 3 4


namespace boost
{




    template< typename C >
    struct range_reverse_iterator
    {
        typedef reverse_iterator<
            typename range_iterator<C>::type > type;
    };


}
# 20 "/usr/include/boost/range/rbegin.hpp" 2 3 4

namespace boost
{
# 35 "/usr/include/boost/range/rbegin.hpp" 3 4
template< class C >
inline typename range_reverse_iterator<C>::type
rbegin( C& c )
{
    typedef typename range_reverse_iterator<C>::type
        iter_type;
    return iter_type( boost::end( c ) );
}

template< class C >
inline typename range_reverse_iterator<const C>::type
rbegin( const C& c )
{
    typedef typename range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::end( c ) );
}



template< class T >
inline typename range_reverse_iterator<const T>::type
const_rbegin( const T& r )
{
    return boost::rbegin( r );
}

}
# 24 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/rend.hpp" 1 3 4
# 21 "/usr/include/boost/range/rend.hpp" 3 4
namespace boost
{
# 35 "/usr/include/boost/range/rend.hpp" 3 4
template< class C >
inline typename range_reverse_iterator<C>::type
rend( C& c )
{
    typedef typename range_reverse_iterator<C>::type
               iter_type;
    return iter_type( boost::begin( c ) );
}

template< class C >
inline typename range_reverse_iterator<const C>::type
rend( const C& c )
{
    typedef typename range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::begin( c ) );
}



template< class T >
inline typename range_reverse_iterator<const T>::type
const_rend( const T& r )
{
    return boost::rend( r );
}

}
# 25 "/usr/include/boost/range/functions.hpp" 2 3 4
# 35 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
# 56 "/usr/include/boost/range/iterator_range.hpp" 3 4
namespace boost
{
    namespace iterator_range_detail
    {




        template<typename IteratorT>
        struct iterator_range_impl {
            template< class ForwardRange >
            static IteratorT adl_begin( ForwardRange& r )
            {
                return IteratorT( boost::begin( r ) );
            }

            template< class ForwardRange >
            static IteratorT adl_end( ForwardRange& r )
            {
                return IteratorT( boost::end( r ) );
            }
        };

        template< class Left, class Right >
        inline bool equal( const Left& l, const Right& r )
        {
            typedef typename boost::range_difference<Left>::type sz_type;

            sz_type l_size = boost::distance( l ),
                    r_size = boost::distance( r );

            if( l_size != r_size )
                return false;

            return std::equal( boost::begin(l), boost::end(l),
                               boost::begin(r) );
        }

        template< class Left, class Right >
        inline bool less_than( const Left& l, const Right& r )
        {
            return std::lexicographical_compare( boost::begin(l),
                                                 boost::end(l),
                                                 boost::begin(r),
                                                 boost::end(r) );
        }

        struct range_tag { };
        struct const_range_tag { };

    }
# 127 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template<typename IteratorT>
        class iterator_range
        {
        protected:

            typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;
        public:


            typedef iterator_range<IteratorT> type;



            typedef typename
                iterator_value<IteratorT>::type value_type;


            typedef typename
                iterator_difference<IteratorT>::type difference_type;


            typedef std::size_t size_type;


            typedef iterator_range<IteratorT> this_type;






            typedef typename
                iterator_reference<IteratorT>::type reference;






            typedef IteratorT const_iterator;

            typedef IteratorT iterator;

        private:
            typedef typename
                boost::mpl::if_< boost::is_abstract<value_type>,
                                 reference, value_type >::type abstract_value_type;

        public:
            iterator_range() : m_Begin( iterator() ), m_End( iterator() )

            , singular( true )

            { }


            template< class Iterator >
            iterator_range( Iterator Begin, Iterator End ) :
                m_Begin(Begin), m_End(End)

            , singular(false)

            {}


            template< class Range >
            iterator_range( const Range& r ) :
                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )

            , singular(false)

            {}


            template< class Range >
            iterator_range( Range& r ) :
                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )

            , singular(false)

            {}


            template< class Range >
            iterator_range( const Range& r, iterator_range_detail::const_range_tag ) :
                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )

            , singular(false)

            {}


            template< class Range >
            iterator_range( Range& r, iterator_range_detail::range_tag ) :
                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )

            , singular(false)

            {}


            this_type& operator=( const this_type& r )
            {
                m_Begin = r.begin();
                m_End = r.end();


                singular = r.singular;

                return *this;
            }


            template< class Iterator >
            iterator_range& operator=( const iterator_range<Iterator>& r )
            {
                m_Begin = r.begin();
                m_End = r.end();

                singular = r.is_singular();

                return *this;
            }

            template< class ForwardRange >
            iterator_range& operator=( ForwardRange& r )
            {
                m_Begin = impl::adl_begin( r );
                m_End = impl::adl_end( r );

                singular = false;

                return *this;
            }

            template< class ForwardRange >
            iterator_range& operator=( const ForwardRange& r )
            {
                m_Begin = impl::adl_begin( r );
                m_End = impl::adl_end( r );

                singular = false;

                return *this;
            }

            IteratorT begin() const
            {
                ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 275, __PRETTY_FUNCTION__));
                return m_Begin;
            }

            IteratorT end() const
            {
                ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 281, __PRETTY_FUNCTION__));
                return m_End;
            }

            difference_type size() const
            {
                ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 287, __PRETTY_FUNCTION__));
                return m_End - m_Begin;
            }

            bool empty() const
            {
                ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 293, __PRETTY_FUNCTION__));
                return m_Begin == m_End;
            }







            typedef iterator (iterator_range::*unspecified_bool_type) () const;
            operator unspecified_bool_type() const
            {
                return empty() ? 0: &iterator_range::end;
            }


            bool equal( const iterator_range& r ) const
            {
                ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 312, __PRETTY_FUNCTION__));
                return m_Begin == r.m_Begin && m_End == r.m_End;
            }
# 339 "/usr/include/boost/range/iterator_range.hpp" 3 4
        public:
           reference front() const
           {
               ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/range/iterator_range.hpp", 342, __PRETTY_FUNCTION__));
               return *m_Begin;
           }

           reference back() const
           {
               ((!empty()) ? static_cast<void> (0) : __assert_fail ("!empty()", "/usr/include/boost/range/iterator_range.hpp", 348, __PRETTY_FUNCTION__));
               IteratorT last( m_End );
               return *--last;
           }

           reference operator[]( difference_type at ) const
           {
               ((at >= 0 && at < size()) ? static_cast<void> (0) : __assert_fail ("at >= 0 && at < size()", "/usr/include/boost/range/iterator_range.hpp", 355, __PRETTY_FUNCTION__));
               return m_Begin[at];
           }






           abstract_value_type operator()( difference_type at ) const
           {
               ((at >= 0 && at < size()) ? static_cast<void> (0) : __assert_fail ("at >= 0 && at < size()", "/usr/include/boost/range/iterator_range.hpp", 366, __PRETTY_FUNCTION__));
               return m_Begin[at];
           }

           iterator_range& advance_begin( difference_type n )
           {
               ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 372, __PRETTY_FUNCTION__));
               std::advance( m_Begin, n );
               return *this;
           }

           iterator_range& advance_end( difference_type n )
           {
               ((!is_singular()) ? static_cast<void> (0) : __assert_fail ("!is_singular()", "/usr/include/boost/range/iterator_range.hpp", 379, __PRETTY_FUNCTION__));
               std::advance( m_End, n );
               return *this;
           }

        private:

            IteratorT m_Begin;
            IteratorT m_End;


            bool singular;


        public:
            bool is_singular() const
            {

                 return singular;



            }

        protected:




            typedef iterator_range iterator_range_;
        };
# 421 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template< typename IteratorT, typename Elem, typename Traits >
        inline std::basic_ostream<Elem,Traits>& operator<<(
                    std::basic_ostream<Elem, Traits>& Os,
                    const iterator_range<IteratorT>& r )
        {
            std::copy( r.begin(), r.end(),
                       std::ostream_iterator< typename
                                              iterator_value<IteratorT>::type,
                                              Elem, Traits>(Os) );
            return Os;
        }
# 456 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template< class IteratorT, class ForwardRange >
        inline bool operator==( const ForwardRange& l,
                                const iterator_range<IteratorT>& r )
        {
            return iterator_range_detail::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline bool operator!=( const ForwardRange& l,
                                const iterator_range<IteratorT>& r )
        {
            return !iterator_range_detail::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline bool operator<( const ForwardRange& l,
                               const iterator_range<IteratorT>& r )
        {
            return iterator_range_detail::less_than( l, r );
        }



        template< class Iterator1T, class Iterator2T >
        inline bool operator==( const iterator_range<Iterator1T>& l,
                                const iterator_range<Iterator2T>& r )
        {
            return iterator_range_detail::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline bool operator==( const iterator_range<IteratorT>& l,
                                const ForwardRange& r )
        {
            return iterator_range_detail::equal( l, r );
        }


        template< class Iterator1T, class Iterator2T >
        inline bool operator!=( const iterator_range<Iterator1T>& l,
                                const iterator_range<Iterator2T>& r )
        {
            return !iterator_range_detail::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline bool operator!=( const iterator_range<IteratorT>& l,
                                const ForwardRange& r )
        {
            return !iterator_range_detail::equal( l, r );
        }


        template< class Iterator1T, class Iterator2T >
        inline bool operator<( const iterator_range<Iterator1T>& l,
                               const iterator_range<Iterator2T>& r )
        {
            return iterator_range_detail::less_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline bool operator<( const iterator_range<IteratorT>& l,
                               const ForwardRange& r )
        {
            return iterator_range_detail::less_than( l, r );
        }
# 535 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template< typename IteratorT >
        inline iterator_range< IteratorT >
        make_iterator_range( IteratorT Begin, IteratorT End )
        {
            return iterator_range<IteratorT>( Begin, End );
        }
# 558 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template< class ForwardRange >
        inline iterator_range< typename range_iterator<ForwardRange>::type >
        make_iterator_range( ForwardRange& r )
        {
           return iterator_range< typename range_iterator<ForwardRange>::type >
                ( r, iterator_range_detail::range_tag() );
        }

        template< class ForwardRange >
        inline iterator_range< typename range_iterator<const ForwardRange>::type >
        make_iterator_range( const ForwardRange& r )
        {
           return iterator_range< typename range_iterator<const ForwardRange>::type >
                ( r, iterator_range_detail::const_range_tag() );
        }



        namespace iterator_range_detail
        {
            template< class Range >
            inline iterator_range< typename range_iterator<Range>::type >
            make_range_impl( Range& r,
                             typename range_difference<Range>::type advance_begin,
                             typename range_difference<Range>::type advance_end )
            {







                typename range_iterator<Range>::type
                    new_begin = boost::begin( r ),
                    new_end = boost::end( r );
                std::advance( new_begin, advance_begin );
                std::advance( new_end, advance_end );
                return make_iterator_range( new_begin, new_end );
            }
        }
# 614 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template< class Range >
        inline iterator_range< typename range_iterator<Range>::type >
        make_iterator_range( Range& r,
                    typename range_difference<Range>::type advance_begin,
                    typename range_difference<Range>::type advance_end )
        {

            return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
        }

        template< class Range >
        inline iterator_range< typename range_iterator<const Range>::type >
        make_iterator_range( const Range& r,
                    typename range_difference<Range>::type advance_begin,
                    typename range_difference<Range>::type advance_end )
        {

            return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
        }
# 644 "/usr/include/boost/range/iterator_range.hpp" 3 4
        template< typename SeqT, typename Range >
        inline SeqT copy_range( const Range& r )
        {
            return SeqT( boost::begin( r ), boost::end( r ) );
        }

}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h" 2


# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_list.h" 1
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h" 2




# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/convert.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/convert.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 1
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h"
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 36 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost/assert.hpp" 2 3 4
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 2



# 1 "/usr/include/boost/call_traits.hpp" 1 3 4
# 21 "/usr/include/boost/call_traits.hpp" 3 4
# 1 "/usr/include/boost/detail/call_traits.hpp" 1 3 4
# 30 "/usr/include/boost/detail/call_traits.hpp" 3 4
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 "/usr/include/boost/detail/call_traits.hpp" 3 4
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 "/usr/include/boost/call_traits.hpp" 2 3 4
# 24 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 2


# 1 "/usr/include/boost/range/iterator_range.hpp" 1 3 4
# 27 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 2



# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/vector.h" 1
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/set.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/set.h"
# 1 "/usr/include/c++/4.1.3/functional" 1 3
# 51 "/usr/include/c++/4.1.3/functional" 3
       
# 52 "/usr/include/c++/4.1.3/functional" 3
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/set.h" 2





namespace atermpp {


template<class T, class Compare = std::less<T>, class Allocator = std::allocator<T> >
class set: public std::set<T, Compare, Allocator>, IProtectedATerm
{
  public:

    set()
    {
      ATprotectProtectedATerm(this);
    }



    explicit set(const Compare& comp)
      : std::set<T, Compare, Allocator>(comp)
    {
      ATprotectProtectedATerm(this);
    }




    set(const Compare& comp, const Allocator& a)
      : std::set<T, Compare, Allocator>(comp, a)
    {
      ATprotectProtectedATerm(this);
    }



    set(const set& right)
      : std::set<T, Compare, Allocator>(right)
    {
      ATprotectProtectedATerm(this);
    }




    template<class InIt>
    set(InIt first, InIt last)
      : std::set<T, Compare, Allocator>(first, last)
    {
      ATprotectProtectedATerm(this);
    }





    template<class InIt>
    set(InIt first, InIt last, const Compare& comp)
      : std::set<T, Compare, Allocator>(first, last, comp)
    {
      ATprotectProtectedATerm(this);
    }






    template<class InIt>
    set(InIt first, InIt last, const Compare& comp, const Allocator& a)
      : std::set<T, Compare, Allocator>(first, last, comp, a)
    {
      ATprotectProtectedATerm(this);
    }


    ~set()
    {
      ATunprotectProtectedATerm(this);
    }



    atermpp::set<T, Compare, Allocator>& operator=(const std::set<T, Compare, Allocator>& other)
    {
      std::set<T, Compare, Allocator>::operator=(other);
      return *this;
    }


    void ATprotectTerms()
    {



      for (typename std::set<T, Compare, Allocator>::iterator i = std::set<T, Compare, Allocator>::begin(); i != std::set<T, Compare, Allocator>::end(); ++i)
      {
        aterm_traits<T>::mark(*i);
      }
    }
};


template<class T, class Compare = std::less<T>, class Allocator = std::allocator<T> >
class multiset: public std::multiset<T, Compare, Allocator>, IProtectedATerm
{
  public:

    multiset()
     : IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }



    explicit multiset(const Compare& comp)
      : std::multiset<T, Compare, Allocator>(comp),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }




    multiset(const Compare& comp, const Allocator& a)
      : std::multiset<T, Compare, Allocator>(comp, a),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }



    multiset(const multiset& right)
      : std::multiset<T, Compare, Allocator>(right),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }




    template<class InIt>
    multiset(InIt first, InIt last)
      : std::multiset<T, Compare, Allocator>(first, last),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }





    template<class InIt>
    multiset(InIt first, InIt last, const Compare& comp)
      : std::multiset<T, Compare, Allocator>(first, last, comp),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }






    template<class InIt>
    multiset(InIt first, InIt last, const Compare& comp, const Allocator& a)
      : std::multiset<T, Compare, Allocator>(first, last, comp, a),
        IProtectedATerm()
    {
      ATprotectProtectedATerm(this);
    }


    ~multiset()
    {
      ATunprotectProtectedATerm(this);
    }


    void ATprotectTerms()
    {



      for (typename std::multiset<T, Compare, Allocator>::iterator i = std::multiset<T, Compare, Allocator>::begin(); i != std::multiset<T, Compare, Allocator>::end(); ++i)
      {
        aterm_traits<T>::mark(*i);
      }
    }
};

}
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 2



namespace atermpp {


    namespace detail {


      template < typename T >
      struct is_container_impl {
        typedef boost::false_type type;
      };

      template < typename T >
      struct is_container_impl< std::set< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< std::multiset< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< atermpp::set< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< atermpp::multiset< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< atermpp::vector< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< std::vector< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< atermpp::term_list< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_container_impl< boost::iterator_range< T > > {
        typedef boost::true_type type;
      };

      template < bool C, typename Container, typename Value >
      struct lazy_check_value_type {
        typedef boost::false_type type;
      };

      template < typename Container, typename ValueType >
      struct lazy_check_value_type< true, Container, ValueType > {
        typedef typename boost::is_convertible< typename Container::value_type, ValueType >::type type;
      };




      template < typename T, typename V = void >
      struct is_container;



      template < typename T >
      struct is_container< T, void > : public
        is_container_impl< typename boost::remove_reference< typename boost::remove_const< T >::type >::type >
      { };

      template < typename T, typename V >
      struct is_container {
        typedef typename lazy_check_value_type< is_container< T, void >::type::value, T, V >::type type;
      };




      template < typename T, typename V = void >
      struct enable_if_container : public
        boost::enable_if< typename atermpp::detail::is_container< T, V >::type >
      {};




      template < typename T, typename V = void >
      struct disable_if_container : public
        boost::disable_if< typename atermpp::detail::is_container< T, V >::type >
      {};

      template < typename T >
      struct is_set_impl {
        typedef boost::false_type type;
      };

      template < typename T >
      struct is_set_impl< std::set< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_set_impl< std::multiset< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_set_impl< atermpp::set< T > > {
        typedef boost::true_type type;
      };

      template < typename T >
      struct is_set_impl< atermpp::multiset< T > > {
        typedef boost::true_type type;
      };


      template < typename T >
      struct is_set : public is_set_impl< typename boost::remove_reference< typename boost::remove_const< T >::type >::type >
      { };


      template < typename AdaptableUnaryFunction, typename Iterator, typename Value = typename AdaptableUnaryFunction::result_type >
      class transform_iterator : public boost::iterator_adaptor<
                 atermpp::detail::transform_iterator< AdaptableUnaryFunction, Iterator, Value >,
                                                        Iterator, Value, boost::use_default, Value > {

        friend class boost::iterator_core_access;

        private:

          mutable AdaptableUnaryFunction m_transformer;

          Value dereference() const
          {
            return m_transformer(*(this->base_reference()));
          }

        public:

          transform_iterator(Iterator const& iterator) : transform_iterator::iterator_adaptor_(iterator)
          {}

          transform_iterator(Iterator const& iterator, typename boost::call_traits< AdaptableUnaryFunction >::param_type transformer) :
                                                         transform_iterator::iterator_adaptor_(iterator), m_transformer(transformer)
          {}
      };

      template < typename AdaptableUnaryFunction, typename ForwardTraversalIterator1, typename ForwardTraversalIterator2 >
      class combine_iterator : public boost::iterator_facade<
                 atermpp::detail::combine_iterator< AdaptableUnaryFunction, ForwardTraversalIterator1, ForwardTraversalIterator2 >,
                         typename boost::remove_reference< AdaptableUnaryFunction >::type::result_type, boost::forward_traversal_tag,
                         typename boost::remove_reference< AdaptableUnaryFunction >::type::result_type > {

        friend class boost::iterator_core_access;

        private:

          AdaptableUnaryFunction m_transformer;
          ForwardTraversalIterator1 m_iterator_1;
          ForwardTraversalIterator2 m_iterator_2;

          typename boost::remove_reference< AdaptableUnaryFunction >::type::result_type dereference() const
          {
            return m_transformer(*m_iterator_1, *m_iterator_2);
          }

          void increment()
          {
            ++m_iterator_1;
            ++m_iterator_2;
          }

          bool equal(combine_iterator const& other) const
          {
            return m_iterator_1 == other.m_iterator_1 && m_iterator_2 == other.m_iterator_2;
          }

        public:

          combine_iterator(typename boost::call_traits< AdaptableUnaryFunction >::param_type transformer,
      ForwardTraversalIterator1 i1, ForwardTraversalIterator2 i2) : m_transformer(transformer), m_iterator_1(i1), m_iterator_2(i2)
          { }
      };

      template < typename AdaptableUnaryFunction, typename ForwardTraversalIterator1, typename ForwardTraversalIterator2 >
      combine_iterator< typename boost::add_reference< AdaptableUnaryFunction >::type, ForwardTraversalIterator1, ForwardTraversalIterator2 >
      make_combine_iterator(AdaptableUnaryFunction f, ForwardTraversalIterator1 const& i1, ForwardTraversalIterator2 const& i2) {
        return combine_iterator< typename boost::add_reference< AdaptableUnaryFunction >::type, ForwardTraversalIterator1, ForwardTraversalIterator2 >(f, i1, i2);
      }

      template < typename Expression, typename Predicate, typename OutputIterator >
      class filter_insert_iterator {

        public:

          typedef std::output_iterator_tag iterator_category;
          typedef Expression value_type;
          typedef void difference_type;
          typedef void pointer;
          typedef void reference;

          struct proxy {
            Predicate m_filter;
            OutputIterator m_sink;

            void operator=(Expression const& p) {
              if (m_filter(p)) {
                *m_sink = static_cast< typename OutputIterator::value_type >(p);
              }
            }

            proxy(Predicate const& filter, OutputIterator const& sink) : m_filter(filter), m_sink(sink) {
            }
          };

        private:

          proxy m_proxy;

        public:

          proxy& operator*() {
            return m_proxy;
          }

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

          filter_insert_iterator& operator++(int) {
            return *this;
          }

          filter_insert_iterator(Predicate const& m_filter, OutputIterator const& sink) : m_proxy(m_filter, sink) {
          }
      };




      template < typename Container, typename Predicate >
      inline filter_insert_iterator< typename Container::value_type, Predicate, std::insert_iterator< Container > >
      make_filter_inserter(Container& c, Predicate const& filter, typename boost::enable_if< typename is_container< Container >::type >::type* = 0) {
        return filter_insert_iterator< typename Container::value_type, Predicate, std::insert_iterator< Container > >(filter, std::inserter(c, c.end()));
      }




      template < typename Expression, typename Predicate, typename OutputIterator >
      inline filter_insert_iterator< Expression, Predicate, OutputIterator >
      make_filter_inserter(Predicate const& filter, OutputIterator& o) {
        return filter_insert_iterator< Expression, Predicate, OutputIterator >(filter, o);
      }

      template < typename Iterator, typename AdaptableUnaryPredicate >
      class filter_iterator : public boost::iterator_adaptor<
                 atermpp::detail::filter_iterator< Iterator, AdaptableUnaryPredicate >, Iterator > {

        friend class boost::iterator_core_access;

        protected:

          AdaptableUnaryPredicate m_predicate;
          Iterator m_end;

          void increment()
          {
            if (this->base_reference() != m_end)
            {
              while (++this->base_reference() != m_end && !m_predicate(*(this->base_reference())))
              { }
            }
          }

        public:

          filter_iterator(AdaptableUnaryPredicate predicate, boost::iterator_range< Iterator > const& range) :
                 filter_iterator::iterator_adaptor_(range.begin()), m_predicate(predicate), m_end(range.end())
          {}

          filter_iterator(AdaptableUnaryPredicate predicate, Iterator begin, Iterator end) :
                 filter_iterator::iterator_adaptor_(begin), m_predicate(predicate), m_end(end)
          {}

          filter_iterator(AdaptableUnaryPredicate predicate, Iterator end) :
                 filter_iterator::iterator_adaptor_(end), m_predicate(predicate), m_end(end)
          {}
      };


      template < typename AdaptableUnaryPredicate, typename Iterator >
      boost::iterator_range< filter_iterator< Iterator, AdaptableUnaryPredicate > >
      make_filter_iterator_range(boost::iterator_range< Iterator > const& r, AdaptableUnaryPredicate predicate)
      {
        typedef filter_iterator< Iterator, AdaptableUnaryPredicate > iterator_type;

        return boost::iterator_range< iterator_type >(
                    iterator_type(predicate, r), iterator_type(predicate, r.end()));
      }



      template < typename Result >
      struct construct {
        typedef Result result_type;

        template < typename A >
        Result operator()(typename boost::call_traits< A >::param_type a) const
        {
          return Result(a);
        }

        template < typename A, typename A1 >
        Result operator()(A a, A1 a1) const
        {
          return Result(a, a1);
        }
      };
    }




    template <typename T>
    atermpp::vector<T> make_vector(const T& t1)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      return v;
    }





    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      return v;
    }






    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2, const T& t3)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      v.push_back(t3);
      return v;
    }







    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2, const T& t3, const T& t4)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      v.push_back(t3);
      v.push_back(t4);
      return v;
    }
# 424 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h"
    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2, const T& t3, const T& t4, const T& t5)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      v.push_back(t3);
      v.push_back(t4);
      v.push_back(t5);
      return v;
    }
# 444 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h"
    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2, const T& t3, const T& t4, const T& t5, const T& t6)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      v.push_back(t3);
      v.push_back(t4);
      v.push_back(t5);
      v.push_back(t6);
      return v;
    }
# 466 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h"
    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2, const T& t3, const T& t4, const T& t5, const T& t6, const T& t7)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      v.push_back(t3);
      v.push_back(t4);
      v.push_back(t5);
      v.push_back(t6);
      v.push_back(t7);
      return v;
    }
# 490 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h"
    template <typename T>
    atermpp::vector<T> make_vector(const T& t1, const T& t2, const T& t3, const T& t4, const T& t5, const T& t6, const T& t7, const T& t8)
    {
      atermpp::vector<T> v;
      v.push_back(t1);
      v.push_back(t2);
      v.push_back(t3);
      v.push_back(t4);
      v.push_back(t5);
      v.push_back(t6);
      v.push_back(t7);
      v.push_back(t8);
      return v;
    }

}
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/convert.h" 2

namespace atermpp {


    namespace detail {

      template < typename Container >
      struct container_value {
        typedef typename Container::value_type type;
      };

      template < >
      struct container_value< ATermList > {
        typedef atermpp::aterm type;
      };

      template < typename TargetContainer, typename SourceContainer,
                 typename TargetExpression = typename container_value< TargetContainer >::type,
                 typename SourceExpression = typename container_value< SourceContainer >::type >
      struct converter {
        template < typename Container >
        static TargetContainer convert(Container const& l) {
          return TargetContainer(l.begin(), l.end());
        }
      };


      template < typename TargetContainer, typename TargetExpression >
      struct converter< TargetContainer, ATermList, TargetExpression, atermpp::aterm > :
                 public converter< TargetContainer, atermpp::term_list< TargetExpression >, TargetExpression, atermpp::aterm > {

        static TargetContainer convert(ATermList l) {
          return converter< TargetContainer, atermpp::term_list< TargetExpression >, TargetExpression, atermpp::aterm >::convert(atermpp::term_list< TargetExpression >(l));
        }
      };


      template < typename TargetExpression, typename SourceExpression >
      struct converter< atermpp::term_list< TargetExpression >,
                        atermpp::term_list< SourceExpression >,
                 TargetExpression, SourceExpression > {

        static atermpp::term_list< TargetExpression >
 convert(atermpp::term_list< SourceExpression > const& r) {
          return atermpp::term_list< TargetExpression >(r);
        }
      };

      template < typename TargetExpression, typename SourceExpression >
      struct converter< atermpp::term_list< TargetExpression >,
                        boost::iterator_range< atermpp::term_list_iterator< SourceExpression > >,
                 TargetExpression, SourceExpression > {

        static atermpp::term_list< TargetExpression >
 convert(boost::iterator_range< atermpp::term_list_iterator< SourceExpression > > const& r) {

          if (((ATbool)(((ATermList)r.end().list())->aterm.head == __null && ((ATermList)r.end().list())->aterm.tail == __null))) {
            return atermpp::term_list< TargetExpression >(r.begin().list());
          }

          return atermpp::term_list< TargetExpression >(r.begin(), r.end());
        }
      };
    }



    template < typename TargetContainer, typename SourceContainer >
    TargetContainer convert(SourceContainer const& c) {
      return detail::converter< TargetContainer, SourceContainer >::convert(c);
    }

}
# 24 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h" 2

namespace mcrl2 {

  namespace data {




    inline
    bool is_sort_expression(const atermpp::aterm_appl& t)
    {
      return core::detail::gsIsSortExpr(t);
    }


    inline bool is_basic_sort(const atermpp::aterm_appl& p) {
      return core::detail::gsIsSortId(p);
    }


    inline bool is_function_sort(const atermpp::aterm_appl& p) {
      return core::detail::gsIsSortArrow(p);
    }


    inline bool is_container_sort(const atermpp::aterm_appl& p) {
      return core::detail::gsIsSortCons(p);
    }


    inline bool is_structured_sort(const atermpp::aterm_appl& p) {
      return core::detail::gsIsSortStruct(p);
    }


    inline bool is_unknown_sort(const atermpp::aterm_appl& p) {
      return core::detail::gsIsSortUnknown(p);
    }


    inline bool is_multiple_possible_sorts(const atermpp::aterm_appl& p) {
      return core::detail::gsIsSortsPossible(p);
    }
# 79 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h"
    class sort_expression: public atermpp::aterm_appl
    {
      public:



        sort_expression()
          : atermpp::aterm_appl(core::detail::constructSortId())
        {}




        sort_expression(const atermpp::aterm_appl& t)
          : atermpp::aterm_appl(t)
        {
          ((is_sort_expression(t)) ? static_cast<void> (0) : __assert_fail ("is_sort_expression(t)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/sort_expression.h", 95, __PRETTY_FUNCTION__));
        }



        inline
        sort_expression target_sort() const
        {
          if(is_function_sort(*this))
          {
            return atermpp::arg2(*this);
          }
          else
          {
            return *this;
          }
        }

    };


    typedef atermpp::term_list< sort_expression > sort_expression_list;

    typedef atermpp::vector< sort_expression > sort_expression_vector;





    template < typename ForwardTraversalIterator >
    inline sort_expression_list make_sort_expression_list(boost::iterator_range< ForwardTraversalIterator > const& r) {
      return atermpp::convert< sort_expression_list >(r);
    }



    template < typename ForwardTraversalIterator >
    inline sort_expression_vector make_sort_expression_vector(boost::iterator_range< ForwardTraversalIterator > const& r) {
      return atermpp::convert< sort_expression_vector >(r);
    }



    template < typename Expression >
    inline sort_expression_list make_sort_expression_list(atermpp::vector< Expression >const& r) {
      return atermpp::convert< sort_expression_list >(r);
    }

  }

}
# 24 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h" 2

namespace mcrl2 {

  namespace data {



class basic_sort: public sort_expression
{
  public:

    basic_sort()
      : sort_expression(core::detail::constructSortId())
    {}



    basic_sort(atermpp::aterm_appl term)
      : sort_expression(term)
    {
      ((core::detail::check_term_SortId(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortId(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/basic_sort.h", 44, __PRETTY_FUNCTION__));
    }


    basic_sort(const core::identifier_string& name)
      : sort_expression(core::detail::gsMakeSortId(name))
    {}


    basic_sort(const std::string& name)
      : sort_expression(core::detail::gsMakeSortId(core::identifier_string(name)))
    {}

    core::identifier_string name() const
    {
      return atermpp::arg1(*this);
    }
};



    typedef atermpp::term_list<basic_sort> basic_sort_list;

    typedef atermpp::vector<basic_sort> basic_sort_vector;

  }

}
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h" 1
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h"
# 1 "/usr/include/boost/range/iterator_range.hpp" 1 3 4
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h" 2



# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/make_list.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/make_list.h"
namespace atermpp
{



  template <typename T0>
  aterm_list make_list(T0 t0)
  {
    return aterm_list(ATmakeList1(aterm_traits<T0>::term(t0)));
  }





  template <typename T0, typename T1>
  aterm_list make_list(T0 t0, T1 t1)
  {
    return aterm_list(ATinsert(ATmakeList1(aterm_traits<T1>::term(t1)), aterm_traits<T0>::term(t0)));
  }






  template <typename T0, typename T1, typename T2>
  aterm_list make_list(T0 t0, T1 t1, T2 t2)
  {
    return aterm_list(ATinsert(ATinsert(ATmakeList1(aterm_traits<T2>::term(t2)), aterm_traits<T1>::term(t1)), aterm_traits<T0>::term(t0)));
  }







  template <typename T0, typename T1, typename T2, typename T3>
  aterm_list make_list(T0 t0, T1 t1, T2 t2, T3 t3)
  {
    return aterm_list(ATinsert(ATinsert(ATinsert(ATmakeList1(aterm_traits<T3>::term(t3)), aterm_traits<T2>::term(t2)), aterm_traits<T1>::term(t1)), aterm_traits<T0>::term(t0)));
  }

}
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h" 2






# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/container_utility.h" 1
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h" 2

namespace mcrl2 {

  namespace data {



class function_sort: public sort_expression
{
  public:

    function_sort()
      : sort_expression(core::detail::constructSortArrow())
    {}



    function_sort(atermpp::aterm_appl term)
      : sort_expression(term)
    {
      ((core::detail::check_term_SortArrow(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortArrow(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h", 48, __PRETTY_FUNCTION__));
    }


    function_sort(const sort_expression_list& domain, const sort_expression& codomain)
      : sort_expression(core::detail::gsMakeSortArrow(domain, codomain))
    {}


    template <typename Container>
    function_sort(const Container& domain, const sort_expression& codomain, typename atermpp::detail::enable_if_container<Container, sort_expression>::type* = 0)
      : sort_expression(core::detail::gsMakeSortArrow(atermpp::convert<sort_expression_list>(domain), codomain))
    {}

    sort_expression_list domain() const
    {
      return atermpp::list_arg1(*this);
    }

    sort_expression codomain() const
    {
      return atermpp::arg2(*this);
    }
};



    typedef atermpp::term_list<function_sort> function_sort_list;

    typedef atermpp::vector<function_sort> function_sort_vector;






    inline function_sort make_function_sort(const sort_expression& dom1,
                  const sort_expression& codomain)
    {
      return function_sort(atermpp::make_list(dom1), codomain);
    }







    inline function_sort make_function_sort(const sort_expression& dom1,
                  const sort_expression& dom2,
                  const sort_expression& codomain)
    {
      return function_sort(atermpp::make_list(dom1, dom2), codomain);
    }
# 110 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h"
    inline function_sort make_function_sort(const sort_expression& dom1,
                  const sort_expression& dom2,
                  const sort_expression& dom3,
                  const sort_expression& codomain)
    {
      return function_sort(atermpp::make_list(dom1, dom2, dom3), codomain);
    }
# 126 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_sort.h"
    inline function_sort make_function_sort(const sort_expression& dom1,
                  const sort_expression& dom2,
                  const sort_expression& dom3,
                  const sort_expression& dom4,
                  const sort_expression& codomain)
    {
      return function_sort(atermpp::make_list(dom1, dom2, dom3, dom4), codomain);
    }

  }

}
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_symbol.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_symbol.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_traits.h" 1
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h" 2







namespace mcrl2 {

  namespace data {




    inline
    bool is_data_expression(atermpp::aterm_appl t)
    {
      return core::detail::gsIsDataExpr(t);
    }


    inline bool is_abstraction(atermpp::aterm_appl p) {
      return core::detail::gsIsBinder(p);
    }


    inline bool is_lambda(atermpp::aterm_appl p) {
      return core::detail::gsIsBinder(p) &&
             core::detail::gsIsLambda(atermpp::arg1(p));
    }


    inline bool is_forall(atermpp::aterm_appl p) {
      return core::detail::gsIsBinder(p) &&
             core::detail::gsIsForall(atermpp::arg1(p));
    }


    inline bool is_exists(atermpp::aterm_appl p) {
      return core::detail::gsIsBinder(p) &&
             core::detail::gsIsExists(atermpp::arg1(p));
    }


    inline bool is_function_symbol(atermpp::aterm_appl p) {
      return core::detail::gsIsOpId(p);
    }


    inline bool is_variable(atermpp::aterm_appl p) {
      return core::detail::gsIsDataVarId(p);
    }


    inline bool is_application(atermpp::aterm_appl p) {
      return core::detail::gsIsDataAppl(p);
    }


    inline bool is_where_clause(atermpp::aterm_appl p) {
      return core::detail::gsIsWhr(p);
    }


    inline bool is_identifier(atermpp::aterm_appl p) {
      return core::detail::gsIsId(p);
    }

    class application;
# 99 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h"
    class data_expression: public atermpp::aterm_appl
    {
      public:



        data_expression()
          : atermpp::aterm_appl(core::detail::constructOpId())
        {}




        data_expression(const atermpp::aterm_appl& t)
          : atermpp::aterm_appl(t)
        {



          ((is_data_expression(t) || core::detail::gsIsNil(t)) ? static_cast<void> (0) : __assert_fail ("is_data_expression(t) || core::detail::gsIsNil(t)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h", 118, __PRETTY_FUNCTION__));
        }

        application operator()(const data_expression& e) const;

        application operator()(const data_expression& e1,
                               const data_expression& e2) const;

        application operator()(const data_expression& e1,
                               const data_expression& e2,
                               const data_expression& e3) const;

        application operator()(const data_expression& e1,
                               const data_expression& e2,
                               const data_expression& e3,
                               const data_expression& e4) const;


        inline
        sort_expression sort() const
        {
          sort_expression result;





          if (is_variable(*this))
          {
            result = atermpp::arg2(*this);
          }
          else if (is_function_symbol(*this))
          {
            result = atermpp::arg2(*this);
          }
          else if (is_abstraction(*this))
          {
            if (is_forall(*this) || is_exists(*this))
            {


              result = data_expression(atermpp::arg3(*this)).sort();
            }
            else
            {
              atermpp::term_list<data_expression> v_variables = atermpp::list_arg2(*this);
              sort_expression_vector s;
              for(atermpp::term_list<data_expression>::const_iterator i = v_variables.begin() ; i != v_variables.end(); ++i)
              {
                s.push_back(i->sort());
              }
              result = function_sort(boost::make_iterator_range(s), data_expression(atermpp::arg3(*this)).sort());
            }
          }
          else if (is_application(*this))
          {
            sort_expression s(data_expression(atermpp::arg1(*this)).sort());
            ((is_function_sort(s)) ? static_cast<void> (0) : __assert_fail ("is_function_sort(s)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h", 175, __PRETTY_FUNCTION__));
            result = atermpp::arg2(s);
          }
          else if (is_where_clause(*this))
          {
            result = data_expression(atermpp::arg1(*this)).sort();
          }
          else
          { std::cerr << "Failing term " << *this << "\n";
            ((false) ? static_cast<void> (0) : __assert_fail ("false", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h", 184, __PRETTY_FUNCTION__));
          }

          return result;
        }

    };



    typedef atermpp::term_list<data_expression> data_expression_list;



    typedef atermpp::vector<data_expression> data_expression_vector;





    template < typename Container >
    inline data_expression_list make_data_expression_list(Container const& r, typename atermpp::detail::enable_if_container< Container, data_expression >::type* = 0)
    {
      return atermpp::convert< data_expression_list >(r);
    }
# 269 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h"
  }

}






# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h" 1
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h" 2

namespace mcrl2 {

  namespace data {

    namespace detail {


class application_base: public data_expression
{
  public:

    application_base()
      : data_expression(core::detail::constructDataAppl())
    {}



    application_base(atermpp::aterm_appl term)
      : data_expression(term)
    {
      ((core::detail::check_term_DataAppl(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_DataAppl(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h", 40, __PRETTY_FUNCTION__));
    }


    application_base(const data_expression& head, const data_expression_list& arguments)
      : data_expression(core::detail::gsMakeDataAppl(head, arguments))
    {}


    template <typename Container>
    application_base(const data_expression& head, const Container& arguments, typename atermpp::detail::enable_if_container<Container, data_expression>::type* = 0)
      : data_expression(core::detail::gsMakeDataAppl(head, atermpp::convert<data_expression_list>(arguments)))
    {}

    data_expression head() const
    {
      return atermpp::arg1(*this);
    }

    data_expression_list arguments() const
    {
      return atermpp::list_arg2(*this);
    }
};


    }






    class application: public detail::application_base
    {
      public:




        application()
          : detail::application_base(core::detail::constructDataAppl())
        {}


        application(atermpp::aterm_appl term)
          : detail::application_base(term)
        {}


        application(const data_expression& head, data_expression_list const& arguments)
          : detail::application_base(head, arguments)
        {}


        template < typename Container >
        application(const data_expression& head,
                    const Container& arguments,
                    typename atermpp::detail::enable_if_container< Container, data_expression >::type* = 0)
          : detail::application_base(head, arguments)
        {




          ((!arguments.empty()) ? static_cast<void> (0) : __assert_fail ("!arguments.empty()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h", 105, __PRETTY_FUNCTION__));
        }




        inline
        data_expression left() const
        {
          ((arguments().size() == 2) ? static_cast<void> (0) : __assert_fail ("arguments().size() == 2", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h", 114, __PRETTY_FUNCTION__));
          return *(arguments().begin());
        }




        inline
        data_expression right() const
        {
          ((arguments().size() == 2) ? static_cast<void> (0) : __assert_fail ("arguments().size() == 2", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h", 124, __PRETTY_FUNCTION__));
          return *(++(arguments().begin()));
        }
    };



    inline data_expression first_argument(data_expression const& e)
    {
      ((!application(e).arguments().empty()) ? static_cast<void> (0) : __assert_fail ("!application(e).arguments().empty()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h", 133, __PRETTY_FUNCTION__));

      return *(application(e).arguments().begin());
    }



    inline data_expression last_argument(data_expression const& e)
    {
      ((!application(e).arguments().empty()) ? static_cast<void> (0) : __assert_fail ("!application(e).arguments().empty()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/application.h", 142, __PRETTY_FUNCTION__));

      data_expression_list r(application(e).arguments());

      for (data_expression_list::const_iterator i = r.begin(), j = i; i != r.end(); i = j++)
      {
        if (j == r.end())
        {
          return *i;
        }
      }

      return *r.begin();
    }


    inline application make_application(data_expression const& head,
                                        data_expression const& e0)
    {



      return application(head, atermpp::make_list(e0));
    }


    inline application make_application(data_expression const& head,
                                        data_expression const& e0,
                                        data_expression const& e1)
    {


      return application(head, atermpp::make_list(e0, e1));
    }


    inline application make_application(data_expression const& head,
                                        data_expression const& e0,
                                        data_expression const& e1,
                                        data_expression const& e2)
    {


      return application(head, atermpp::make_list(e0, e1, e2));
    }


    inline application make_application(data_expression const& head,
                                        data_expression const& e0,
                                        data_expression const& e1,
                                        data_expression const& e2,
                                        data_expression const& e3)
    {


      return application(head, atermpp::make_list(e0, e1, e2, e3));
    }

  }

}
# 279 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_expression.h" 2


namespace mcrl2 {
  namespace data {


    inline
    application data_expression::operator()(const data_expression& e) const
    {
      return make_application(*this, e);
    }


    inline
    application data_expression::operator()(const data_expression& e1, const data_expression& e2) const
    {
      return make_application(*this, e1, e2);
    }


    inline
    application data_expression::operator()(const data_expression& e1, const data_expression& e2, const data_expression& e3) const
    {
      return make_application(*this, e1, e2, e3);
    }


    inline
    application data_expression::operator()(const data_expression& e1, const data_expression& e2, const data_expression& e3, const data_expression& e4) const
    {
      return make_application(*this, e1, e2, e3, e4);
    }

  }
}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_symbol.h" 2



namespace mcrl2 {

  namespace data {



class function_symbol: public data_expression
{
  public:

    function_symbol()
      : data_expression(core::detail::constructOpId())
    {}



    function_symbol(atermpp::aterm_appl term)
      : data_expression(term)
    {
      ((core::detail::check_term_OpId(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_OpId(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_symbol.h", 41, __PRETTY_FUNCTION__));
    }


    function_symbol(const core::identifier_string& name, const sort_expression& sort)
      : data_expression(core::detail::gsMakeOpId(name, sort))
    {}


    function_symbol(const std::string& name, const sort_expression& sort)
      : data_expression(core::detail::gsMakeOpId(core::identifier_string(name), sort))
    {}

    core::identifier_string name() const
    {
      return atermpp::arg1(*this);
    }

    sort_expression sort() const
    {
      return atermpp::arg2(*this);
    }
};



    typedef atermpp::term_list< function_symbol > function_symbol_list;


    typedef atermpp::vector< function_symbol > function_symbol_vector;

  }

}
# 24 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_equation.h" 1
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_equation.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/variable.h" 1
# 26 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/variable.h"
namespace mcrl2 {

  namespace data {



class variable: public data_expression
{
  public:

    variable()
      : data_expression(core::detail::constructDataVarId())
    {}



    variable(atermpp::aterm_appl term)
      : data_expression(term)
    {
      ((core::detail::check_term_DataVarId(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_DataVarId(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/variable.h", 45, __PRETTY_FUNCTION__));
    }


    variable(const core::identifier_string& name, const sort_expression& sort)
      : data_expression(core::detail::gsMakeDataVarId(name, sort))
    {}


    variable(const std::string& name, const sort_expression& sort)
      : data_expression(core::detail::gsMakeDataVarId(core::identifier_string(name), sort))
    {}

    core::identifier_string name() const
    {
      return atermpp::arg1(*this);
    }

    sort_expression sort() const
    {
      return atermpp::arg2(*this);
    }
};



    typedef atermpp::term_list< variable > variable_list;

    typedef atermpp::vector< variable > variable_vector;





    template < typename Container >
    inline variable_list make_variable_list(Container const& r, typename atermpp::detail::enable_if_container< Container, variable >::type* = 0)
    {
      return atermpp::convert< variable_list >(r);
    }

  }

}
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_equation.h" 2





namespace mcrl2 {

  namespace data {


    namespace sort_bool {
      function_symbol const& true_();
    }



    class data_equation: public atermpp::aterm_appl
    {
      public:


        typedef atermpp::term_list< variable > variables_const;


        typedef atermpp::term_list< variable > variables_const_range;

      public:



        data_equation()
          : atermpp::aterm_appl(core::detail::constructDataEqn())
        {}




        data_equation(const atermpp::aterm_appl& a)
          : atermpp::aterm_appl(a)
        { }







        template < typename Container >
        data_equation(const Container& variables,
                      const data_expression& condition,
                      const data_expression& lhs,
                      const data_expression& rhs,
                      typename atermpp::detail::enable_if_container< Container, variable >::type* = 0)
          : atermpp::aterm_appl(core::detail::gsMakeDataEqn(
                  atermpp::convert< variable_list >(variables), condition, lhs, rhs))
        {}
# 87 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_equation.h"
        template < typename Container >
        data_equation(const Container& variables,
                      const data_expression& lhs,
                      const data_expression& rhs,
                      typename atermpp::detail::enable_if_container< Container, variable >::type* = 0)
          : atermpp::aterm_appl(core::detail::gsMakeDataEqn(
                  atermpp::convert< variable_list >(variables), sort_bool::true_(), lhs, rhs))
        {}
# 103 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/data_equation.h"
        data_equation(const data_expression& condition,
                      const data_expression& lhs,
                      const data_expression& rhs)
          : atermpp::aterm_appl(core::detail::gsMakeDataEqn(
                  variable_list(), condition, lhs, rhs))
        {}







        data_equation(const data_expression& lhs,
                      const data_expression& rhs)
          : atermpp::aterm_appl(core::detail::gsMakeDataEqn(
                  variable_list(), sort_bool::true_(), lhs, rhs))
        {}


        variables_const_range variables() const
        {
          return atermpp::list_arg1(appl());
        }


        data_expression condition() const
        {
          return atermpp::arg2(*this);
        }


        data_expression lhs() const
        {
          return atermpp::arg3(*this);
        }


        data_expression rhs() const
        {
          return atermpp::arg4(*this);
        }

    };


    typedef atermpp::term_list< data_equation > data_equation_list;


    typedef atermpp::vector< data_equation > data_equation_vector;

  }

}
# 26 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/detail/construction_utility.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/detail/construction_utility.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/aterm_appl.h" 1
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/detail/construction_utility.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/identifier_string.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/detail/construction_utility.h" 2

namespace mcrl2 {
  namespace data {
    namespace detail {





      template < typename Expression >
      Expression const& initialise_static_expression(Expression& target, Expression const& original)
      {
        target = original;
        target.protect();

        return original;
      }


      template < typename Derived, typename Expression = atermpp::aterm_appl >
      struct singleton_expression : public Expression
      {
        static Expression const& instance()
        {
          static Expression single_instance = initialise_static_expression(single_instance, Expression(Derived::initialise()));

          return single_instance;
        }

        singleton_expression() : Expression(instance())
        { }
      };

      template < typename Derived >
      struct singleton_identifier : public singleton_expression< Derived, core::identifier_string >
      {};

    }
  }
}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h" 2


namespace mcrl2 {

  namespace data {


    namespace sort_bool {
      basic_sort const& bool_();
      function_symbol const& false_();
      function_symbol const& true_();
      application not_(const data_expression&);
      bool is_bool(const sort_expression&);
    }


    namespace detail {


      template < typename Derived >
      struct symbol : public detail::singleton_identifier< Derived > {
        static bool is_application(data_expression const& e)
        {
          return data::is_application(e) ? is_application(application(e)) : false;
        }

        static bool is_application(application const& e)
        {
          return is_function_symbol(e.head());
        }

        static bool is_function_symbol(data_expression const& e)
        {
          return data::is_function_symbol(e) ? is_function_symbol(function_symbol(e)) : false;
        }

        static bool is_function_symbol(function_symbol const& e)
        {
          return e.name() == detail::singleton_identifier< Derived >();
        }
      };

      struct equal_symbol : public symbol< equal_symbol > {
        static char const* initialise() {
          return "==";
        }
      };
      struct not_equal_symbol : public symbol< not_equal_symbol > {
        static char const* initialise() {
          return "!=";
        }
      };
      struct if_symbol : public symbol< if_symbol > {
        static char const* initialise() {
          return "if";
        }
      };
      struct less_symbol : public symbol< less_symbol > {
        static char const* initialise() {
          return "<";
        }
      };
      struct less_equal_symbol : public symbol< less_equal_symbol > {
        static char const* initialise() {
          return "<=";
        }
      };
      struct greater_symbol : public symbol< greater_symbol > {
        static char const* initialise() {
          return ">";
        }
      };
      struct greater_equal_symbol : public symbol< greater_equal_symbol > {
        static char const* initialise() {
          return ">=";
        }
      };
    }





    inline function_symbol equal_to(const sort_expression& s)
    {
      return function_symbol(detail::equal_symbol(), make_function_sort(s, s, sort_bool::bool_()));
    }




    template < typename DataExpression >
    inline bool is_equal_to_function_symbol(const DataExpression& e)
    {
      return detail::equal_symbol::is_function_symbol(e);
    }





    inline application equal_to(const data_expression& arg0, const data_expression& arg1)
    {
      ((arg0.sort() == arg1.sort()) ? static_cast<void> (0) : __assert_fail ("arg0.sort() == arg1.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 122, __PRETTY_FUNCTION__));
      return equal_to(arg0.sort())(arg0, arg1);
    }





    template < typename DataExpression >
    inline bool is_equal_to_application(const DataExpression& e)
    {
      return detail::equal_symbol::is_application(e);
    }




    inline function_symbol not_equal_to(const sort_expression& s)
    {
      return function_symbol(detail::not_equal_symbol(), make_function_sort(s, s, sort_bool::bool_()));
    }




    template < typename DataExpression >
    inline bool is_not_equal_to_function_symbol(const DataExpression& e)
    {
      return detail::not_equal_symbol::is_function_symbol(e);
    }





    inline application not_equal_to(const data_expression& arg0, const data_expression& arg1)
    {
      ((arg0.sort() == arg1.sort()) ? static_cast<void> (0) : __assert_fail ("arg0.sort() == arg1.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 159, __PRETTY_FUNCTION__));
      return not_equal_to(arg0.sort())(arg0, arg1);
    }





    template < typename DataExpression >
    inline bool is_not_equal_to_application(const DataExpression& e)
    {
      return detail::not_equal_symbol::is_application(e);
    }




    inline function_symbol if_(const sort_expression& s)
    {
      return function_symbol(detail::if_symbol(), make_function_sort(sort_bool::bool_(), s, s, s));
    }




    template < typename DataExpression >
    inline bool is_if_function_symbol(const DataExpression& e)
    {
      return detail::if_symbol::is_function_symbol(e);
    }






    inline application if_(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
    {
      ((sort_bool::is_bool(arg0.sort())) ? static_cast<void> (0) : __assert_fail ("sort_bool::is_bool(arg0.sort())", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 197, __PRETTY_FUNCTION__));
      ((arg1.sort() == arg2.sort()) ? static_cast<void> (0) : __assert_fail ("arg1.sort() == arg2.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 198, __PRETTY_FUNCTION__));

      return if_(arg1.sort())(arg0, arg1, arg2);
    }





    template < typename DataExpression >
    inline bool is_if_application(const DataExpression& e)
    {
      return detail::if_symbol::is_application(e);
    }




    inline function_symbol less(const sort_expression& s)
    {
      return function_symbol(detail::less_symbol(), make_function_sort(s, s, sort_bool::bool_()));
    }




    template < typename DataExpression >
    inline bool is_less_function_symbol(const DataExpression& e)
    {
      return detail::less_symbol::is_function_symbol(e);
    }





    inline application less(const data_expression& arg0, const data_expression& arg1)
    {
      ((arg0.sort() == arg1.sort()) ? static_cast<void> (0) : __assert_fail ("arg0.sort() == arg1.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 236, __PRETTY_FUNCTION__));
      return less(arg0.sort())(arg0, arg1);
    }





    template < typename DataExpression >
    inline bool is_less_application(const DataExpression& e)
    {
      return detail::less_symbol::is_application(e);
    }




    inline function_symbol less_equal(const sort_expression& s)
    {
      return function_symbol(detail::less_equal_symbol(), make_function_sort(s, s, sort_bool::bool_()));
    }




    template < typename DataExpression >
    inline bool is_less_equal_function_symbol(const DataExpression& e)
    {
      return detail::less_equal_symbol::is_function_symbol(e);
    }





    inline application less_equal(const data_expression& arg0, const data_expression& arg1)
    {
      ((arg0.sort() == arg1.sort()) ? static_cast<void> (0) : __assert_fail ("arg0.sort() == arg1.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 273, __PRETTY_FUNCTION__));
      return less_equal(arg0.sort())(arg0, arg1);
    }





    template < typename DataExpression >
    inline bool is_less_equal_application(const DataExpression& e)
    {
      return detail::less_equal_symbol::is_application(e);
    }




    inline function_symbol greater(const sort_expression& s)
    {
      return function_symbol(detail::greater_symbol(), make_function_sort(s, s, sort_bool::bool_()));
    }




    template < typename DataExpression >
    inline bool is_greater_function_symbol(const DataExpression& e)
    {
      return detail::greater_symbol::is_function_symbol(e);
    }





    inline application greater(const data_expression& arg0, const data_expression& arg1)
    {
      ((arg0.sort() == arg1.sort()) ? static_cast<void> (0) : __assert_fail ("arg0.sort() == arg1.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 310, __PRETTY_FUNCTION__));
      return greater(arg0.sort())(arg0, arg1);
    }





    template < typename DataExpression >
    inline bool is_greater_application(const DataExpression& e)
    {
      return detail::greater_symbol::is_application(e);
    }




    inline function_symbol greater_equal(const sort_expression& s)
    {
      return function_symbol(detail::greater_equal_symbol(), make_function_sort(s, s, sort_bool::bool_()));
    }




    template < typename DataExpression >
    inline bool is_greater_equal_function_symbol(const DataExpression& e)
    {
      return detail::greater_equal_symbol::is_function_symbol(e);
    }





    inline application greater_equal(const data_expression& arg0, const data_expression& arg1)
    {
      ((arg0.sort() == arg1.sort()) ? static_cast<void> (0) : __assert_fail ("arg0.sort() == arg1.sort()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h", 347, __PRETTY_FUNCTION__));
      return greater_equal(arg0.sort())(arg0, arg1);
    }





    template < typename DataExpression >
    inline bool is_greater_equal_application(const DataExpression& e)
    {
      return detail::greater_equal_symbol::is_application(e);
    }




    inline function_symbol_vector standard_generate_functions_code(const sort_expression& s)
    {
      function_symbol_vector result;
      result.push_back(equal_to(s));
      result.push_back(not_equal_to(s));
      result.push_back(if_(s));
      result.push_back(less(s));
      result.push_back(less_equal(s));
      result.push_back(greater_equal(s));
      result.push_back(greater(s));

      return result;
    }




    inline data_equation_vector standard_generate_equations_code(const sort_expression& s)
    {
      data_equation_vector result;
      variable b("b", sort_bool::bool_());
      variable x("x", s);
      variable y("y", s);
      result.push_back(data_equation(atermpp::make_vector(x), equal_to(x, x), sort_bool::true_()));
      result.push_back(data_equation(atermpp::make_vector(x, y), not_equal_to(x, y), sort_bool::not_(equal_to(x, y))));
      result.push_back(data_equation(atermpp::make_vector(x, y), if_(sort_bool::true_(), x, y), x));
      result.push_back(data_equation(atermpp::make_vector(x, y), if_(sort_bool::false_(), x, y), y));
      result.push_back(data_equation(atermpp::make_vector(b, x), if_(b, x, x), x));
      result.push_back(data_equation(atermpp::make_vector(x), less(x,x), sort_bool::false_()));
      result.push_back(data_equation(atermpp::make_vector(x), less_equal(x,x), sort_bool::true_()));
      result.push_back(data_equation(atermpp::make_vector(x, y), greater_equal(x,y), less_equal(y,x)));
      result.push_back(data_equation(atermpp::make_vector(x, y), greater(x,y), less(y,x)));

      return result;
    }

  }
}
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_bool {

      inline
      core::identifier_string const& bool_name()
      {
        static core::identifier_string bool_name = data::detail::initialise_static_expression(bool_name, core::identifier_string("Bool"));
        return bool_name;
      }



      inline
      basic_sort const& bool_()
      {
        static basic_sort bool_ = data::detail::initialise_static_expression(bool_, basic_sort(bool_name()));
        return bool_;
      }




      inline
      bool is_bool(const sort_expression& e)
      {
        if (is_basic_sort(e))
        {
          return basic_sort(e) == bool_();
        }
        return false;
      }



      inline
      core::identifier_string const& true_name()
      {
        static core::identifier_string true_name = data::detail::initialise_static_expression(true_name, core::identifier_string("true"));
        return true_name;
      }



      inline
      function_symbol const& true_()
      {
        static function_symbol true_ = data::detail::initialise_static_expression(true_, function_symbol(true_name(), bool_()));
        return true_;
      }





      inline
      bool is_true_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == true_();
        }
        return false;
      }



      inline
      core::identifier_string const& false_name()
      {
        static core::identifier_string false_name = data::detail::initialise_static_expression(false_name, core::identifier_string("false"));
        return false_name;
      }



      inline
      function_symbol const& false_()
      {
        static function_symbol false_ = data::detail::initialise_static_expression(false_, function_symbol(false_name(), bool_()));
        return false_;
      }





      inline
      bool is_false_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == false_();
        }
        return false;
      }



      inline
      function_symbol_vector bool_generate_constructors_code()
      {
        function_symbol_vector result;
        result.push_back(true_());
        result.push_back(false_());

        return result;
      }


      inline
      core::identifier_string const& not_name()
      {
        static core::identifier_string not_name = data::detail::initialise_static_expression(not_name, core::identifier_string("!"));
        return not_name;
      }



      inline
      function_symbol const& not_()
      {
        static function_symbol not_ = data::detail::initialise_static_expression(not_, function_symbol(not_name(), make_function_sort(bool_(), bool_())));
        return not_;
      }





      inline
      bool is_not_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == not_();
        }
        return false;
      }




      inline
      application not_(const data_expression& arg0)
      {
        return not_()(arg0);
      }





      inline
      bool is_not_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_not_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& and_name()
      {
        static core::identifier_string and_name = data::detail::initialise_static_expression(and_name, core::identifier_string("&&"));
        return and_name;
      }



      inline
      function_symbol const& and_()
      {
        static function_symbol and_ = data::detail::initialise_static_expression(and_, function_symbol(and_name(), make_function_sort(bool_(), bool_(), bool_())));
        return and_;
      }





      inline
      bool is_and_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == and_();
        }
        return false;
      }





      inline
      application and_(const data_expression& arg0, const data_expression& arg1)
      {
        return and_()(arg0, arg1);
      }





      inline
      bool is_and_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_and_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& or_name()
      {
        static core::identifier_string or_name = data::detail::initialise_static_expression(or_name, core::identifier_string("||"));
        return or_name;
      }



      inline
      function_symbol const& or_()
      {
        static function_symbol or_ = data::detail::initialise_static_expression(or_, function_symbol(or_name(), make_function_sort(bool_(), bool_(), bool_())));
        return or_;
      }





      inline
      bool is_or_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == or_();
        }
        return false;
      }





      inline
      application or_(const data_expression& arg0, const data_expression& arg1)
      {
        return or_()(arg0, arg1);
      }





      inline
      bool is_or_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_or_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& implies_name()
      {
        static core::identifier_string implies_name = data::detail::initialise_static_expression(implies_name, core::identifier_string("=>"));
        return implies_name;
      }



      inline
      function_symbol const& implies()
      {
        static function_symbol implies = data::detail::initialise_static_expression(implies, function_symbol(implies_name(), make_function_sort(bool_(), bool_(), bool_())));
        return implies;
      }





      inline
      bool is_implies_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == implies();
        }
        return false;
      }





      inline
      application implies(const data_expression& arg0, const data_expression& arg1)
      {
        return implies()(arg0, arg1);
      }





      inline
      bool is_implies_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_implies_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector bool_generate_functions_code()
      {
        function_symbol_vector result;
        result.push_back(not_());
        result.push_back(and_());
        result.push_back(or_());
        result.push_back(implies());
        return result;
      }





      inline
      data_expression left(const data_expression& e)
      {
        ((is_and_application(e) || is_or_application(e) || is_implies_application(e)) ? static_cast<void> (0) : __assert_fail ("is_and_application(e) || is_or_application(e) || is_implies_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h", 383, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression right(const data_expression& e)
      {
        ((is_and_application(e) || is_or_application(e) || is_implies_application(e)) ? static_cast<void> (0) : __assert_fail ("is_and_application(e) || is_or_application(e) || is_implies_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h", 395, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_not_application(e)) ? static_cast<void> (0) : __assert_fail ("is_not_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h", 407, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }



      inline
      data_equation_vector bool_generate_equations_code()
      {
        variable vb("b",bool_());

        data_equation_vector result;
        result.push_back(data_equation(variable_list(), not_(true_()), false_()));
        result.push_back(data_equation(variable_list(), not_(false_()), true_()));
        result.push_back(data_equation(atermpp::make_vector(vb), not_(not_(vb)), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), and_(vb, true_()), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), and_(vb, false_()), false_()));
        result.push_back(data_equation(atermpp::make_vector(vb), and_(true_(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), and_(false_(), vb), false_()));
        result.push_back(data_equation(atermpp::make_vector(vb), or_(vb, true_()), true_()));
        result.push_back(data_equation(atermpp::make_vector(vb), or_(vb, false_()), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), or_(true_(), vb), true_()));
        result.push_back(data_equation(atermpp::make_vector(vb), or_(false_(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), implies(vb, true_()), true_()));
        result.push_back(data_equation(atermpp::make_vector(vb), implies(vb, false_()), not_(vb)));
        result.push_back(data_equation(atermpp::make_vector(vb), implies(true_(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), implies(false_(), vb), true_()));
        result.push_back(data_equation(atermpp::make_vector(vb), equal_to(true_(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), equal_to(false_(), vb), not_(vb)));
        result.push_back(data_equation(atermpp::make_vector(vb), equal_to(vb, true_()), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), equal_to(vb, false_()), not_(vb)));
        result.push_back(data_equation(atermpp::make_vector(vb), less(false_(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), less(true_(), vb), false_()));
        result.push_back(data_equation(atermpp::make_vector(vb), less(vb, false_()), false_()));
        result.push_back(data_equation(atermpp::make_vector(vb), less(vb, true_()), not_(vb)));
        result.push_back(data_equation(atermpp::make_vector(vb), less_equal(false_(), vb), true_()));
        result.push_back(data_equation(atermpp::make_vector(vb), less_equal(true_(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb), less_equal(vb, false_()), not_(vb)));
        result.push_back(data_equation(atermpp::make_vector(vb), less_equal(vb, true_()), true_()));
        return result;
      }

    }

  }

}
# 34 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h" 1
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bool.h" 1
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_pos {

      inline
      core::identifier_string const& pos_name()
      {
        static core::identifier_string pos_name = data::detail::initialise_static_expression(pos_name, core::identifier_string("Pos"));
        return pos_name;
      }



      inline
      basic_sort const& pos()
      {
        static basic_sort pos = data::detail::initialise_static_expression(pos, basic_sort(pos_name()));
        return pos;
      }




      inline
      bool is_pos(const sort_expression& e)
      {
        if (is_basic_sort(e))
        {
          return basic_sort(e) == pos();
        }
        return false;
      }



      inline
      core::identifier_string const& c1_name()
      {
        static core::identifier_string c1_name = data::detail::initialise_static_expression(c1_name, core::identifier_string("@c1"));
        return c1_name;
      }



      inline
      function_symbol const& c1()
      {
        static function_symbol c1 = data::detail::initialise_static_expression(c1, function_symbol(c1_name(), pos()));
        return c1;
      }





      inline
      bool is_c1_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == c1();
        }
        return false;
      }



      inline
      core::identifier_string const& cdub_name()
      {
        static core::identifier_string cdub_name = data::detail::initialise_static_expression(cdub_name, core::identifier_string("@cDub"));
        return cdub_name;
      }



      inline
      function_symbol const& cdub()
      {
        static function_symbol cdub = data::detail::initialise_static_expression(cdub, function_symbol(cdub_name(), make_function_sort(sort_bool::bool_(), pos(), pos())));
        return cdub;
      }





      inline
      bool is_cdub_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == cdub();
        }
        return false;
      }





      inline
      application cdub(const data_expression& arg0, const data_expression& arg1)
      {
        return cdub()(arg0, arg1);
      }





      inline
      bool is_cdub_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_cdub_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector pos_generate_constructors_code()
      {
        function_symbol_vector result;
        result.push_back(c1());
        result.push_back(cdub());

        return result;
      }


      inline
      core::identifier_string const& maximum_name()
      {
        static core::identifier_string maximum_name = data::detail::initialise_static_expression(maximum_name, core::identifier_string("max"));
        return maximum_name;
      }



      inline
      function_symbol const& maximum()
      {
        static function_symbol maximum = data::detail::initialise_static_expression(maximum, function_symbol(maximum_name(), make_function_sort(pos(), pos(), pos())));
        return maximum;
      }





      inline
      bool is_maximum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == maximum();
        }
        return false;
      }





      inline
      application maximum(const data_expression& arg0, const data_expression& arg1)
      {
        return maximum()(arg0, arg1);
      }





      inline
      bool is_maximum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_maximum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& minimum_name()
      {
        static core::identifier_string minimum_name = data::detail::initialise_static_expression(minimum_name, core::identifier_string("min"));
        return minimum_name;
      }



      inline
      function_symbol const& minimum()
      {
        static function_symbol minimum = data::detail::initialise_static_expression(minimum, function_symbol(minimum_name(), make_function_sort(pos(), pos(), pos())));
        return minimum;
      }





      inline
      bool is_minimum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == minimum();
        }
        return false;
      }





      inline
      application minimum(const data_expression& arg0, const data_expression& arg1)
      {
        return minimum()(arg0, arg1);
      }





      inline
      bool is_minimum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_minimum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& abs_name()
      {
        static core::identifier_string abs_name = data::detail::initialise_static_expression(abs_name, core::identifier_string("abs"));
        return abs_name;
      }



      inline
      function_symbol const& abs()
      {
        static function_symbol abs = data::detail::initialise_static_expression(abs, function_symbol(abs_name(), make_function_sort(pos(), pos())));
        return abs;
      }





      inline
      bool is_abs_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == abs();
        }
        return false;
      }




      inline
      application abs(const data_expression& arg0)
      {
        return abs()(arg0);
      }





      inline
      bool is_abs_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_abs_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& succ_name()
      {
        static core::identifier_string succ_name = data::detail::initialise_static_expression(succ_name, core::identifier_string("succ"));
        return succ_name;
      }



      inline
      function_symbol const& succ()
      {
        static function_symbol succ = data::detail::initialise_static_expression(succ, function_symbol(succ_name(), make_function_sort(pos(), pos())));
        return succ;
      }





      inline
      bool is_succ_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == succ();
        }
        return false;
      }




      inline
      application succ(const data_expression& arg0)
      {
        return succ()(arg0);
      }





      inline
      bool is_succ_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_succ_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& plus_name()
      {
        static core::identifier_string plus_name = data::detail::initialise_static_expression(plus_name, core::identifier_string("+"));
        return plus_name;
      }



      inline
      function_symbol const& plus()
      {
        static function_symbol plus = data::detail::initialise_static_expression(plus, function_symbol(plus_name(), make_function_sort(pos(), pos(), pos())));
        return plus;
      }





      inline
      bool is_plus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == plus();
        }
        return false;
      }





      inline
      application plus(const data_expression& arg0, const data_expression& arg1)
      {
        return plus()(arg0, arg1);
      }





      inline
      bool is_plus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_plus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& add_with_carry_name()
      {
        static core::identifier_string add_with_carry_name = data::detail::initialise_static_expression(add_with_carry_name, core::identifier_string("@addc"));
        return add_with_carry_name;
      }



      inline
      function_symbol const& add_with_carry()
      {
        static function_symbol add_with_carry = data::detail::initialise_static_expression(add_with_carry, function_symbol(add_with_carry_name(), make_function_sort(sort_bool::bool_(), pos(), pos(), pos())));
        return add_with_carry;
      }





      inline
      bool is_add_with_carry_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == add_with_carry();
        }
        return false;
      }






      inline
      application add_with_carry(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return add_with_carry()(arg0, arg1, arg2);
      }





      inline
      bool is_add_with_carry_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_add_with_carry_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& times_name()
      {
        static core::identifier_string times_name = data::detail::initialise_static_expression(times_name, core::identifier_string("*"));
        return times_name;
      }



      inline
      function_symbol const& times()
      {
        static function_symbol times = data::detail::initialise_static_expression(times, function_symbol(times_name(), make_function_sort(pos(), pos(), pos())));
        return times;
      }





      inline
      bool is_times_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == times();
        }
        return false;
      }





      inline
      application times(const data_expression& arg0, const data_expression& arg1)
      {
        return times()(arg0, arg1);
      }





      inline
      bool is_times_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_times_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& multir_name()
      {
        static core::identifier_string multir_name = data::detail::initialise_static_expression(multir_name, core::identifier_string("@multir"));
        return multir_name;
      }



      inline
      function_symbol const& multir()
      {
        static function_symbol multir = data::detail::initialise_static_expression(multir, function_symbol(multir_name(), make_function_sort(sort_bool::bool_(), pos(), pos(), pos(), pos())));
        return multir;
      }





      inline
      bool is_multir_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == multir();
        }
        return false;
      }







      inline
      application multir(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return multir()(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_multir_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_multir_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector pos_generate_functions_code()
      {
        function_symbol_vector result;
        result.push_back(maximum());
        result.push_back(minimum());
        result.push_back(abs());
        result.push_back(succ());
        result.push_back(plus());
        result.push_back(add_with_carry());
        result.push_back(times());
        result.push_back(multir());
        return result;
      }





      inline
      data_expression right(const data_expression& e)
      {
        ((is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_add_with_carry_application(e) || is_times_application(e)) ? static_cast<void> (0) : __assert_fail ("is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_add_with_carry_application(e) || is_times_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 638, __PRETTY_FUNCTION__));
        if (is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_times_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        if (is_add_with_carry_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 2);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_multir_application(e)) ? static_cast<void> (0) : __assert_fail ("is_multir_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 658, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_multir_application(e)) ? static_cast<void> (0) : __assert_fail ("is_multir_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 670, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }






      inline
      data_expression arg3(const data_expression& e)
      {
        ((is_multir_application(e)) ? static_cast<void> (0) : __assert_fail ("is_multir_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 682, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 3);
      }






      inline
      data_expression number(const data_expression& e)
      {
        ((is_cdub_application(e) || is_abs_application(e) || is_succ_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cdub_application(e) || is_abs_application(e) || is_succ_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 694, __PRETTY_FUNCTION__));
        if (is_abs_application(e) || is_succ_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 0);
        }
        if (is_cdub_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression bit(const data_expression& e)
      {
        ((is_cdub_application(e) || is_add_with_carry_application(e) || is_multir_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cdub_application(e) || is_add_with_carry_application(e) || is_multir_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 714, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_add_with_carry_application(e) || is_times_application(e)) ? static_cast<void> (0) : __assert_fail ("is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_add_with_carry_application(e) || is_times_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h", 726, __PRETTY_FUNCTION__));
        if (is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_times_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 0);
        }
        if (is_add_with_carry_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }



      inline
      data_equation_vector pos_generate_equations_code()
      {
        variable vb("b",sort_bool::bool_());
        variable vc("c",sort_bool::bool_());
        variable vp("p",pos());
        variable vq("q",pos());
        variable vr("r",pos());

        data_equation_vector result;
        result.push_back(data_equation(atermpp::make_vector(vb, vp), equal_to(c1(), cdub(vb, vp)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), equal_to(cdub(vb, vp), c1()), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), equal_to(cdub(sort_bool::false_(), vp), cdub(sort_bool::true_(), vq)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), equal_to(cdub(sort_bool::true_(), vp), cdub(sort_bool::false_(), vq)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), equal_to(cdub(vb, vp), cdub(vb, vq)), equal_to(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vp, vq), equal_to(cdub(vb, vp), cdub(vc, vq)), sort_bool::and_(equal_to(vb, vc), equal_to(vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp), less(vp, c1()), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), less(c1(), cdub(vb, vp)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), less(cdub(vb, vp), cdub(vb, vq)), less(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(cdub(sort_bool::false_(), vp), cdub(sort_bool::true_(), vq)), less_equal(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), less(cdub(vb, vp), cdub(sort_bool::false_(), vq)), less(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vp, vq), less(cdub(vb, vp), cdub(vc, vq)), if_(sort_bool::implies(vc, vb), less(vp, vq), less_equal(vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp), less_equal(c1(), vp), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), less_equal(cdub(vb, vp), c1()), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), less_equal(cdub(vb, vp), cdub(vb, vq)), less_equal(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), less_equal(cdub(sort_bool::false_(), vp), cdub(vb, vq)), less_equal(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(cdub(sort_bool::true_(), vp), cdub(sort_bool::false_(), vq)), less(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vp, vq), less_equal(cdub(vb, vp), cdub(vc, vq)), if_(sort_bool::implies(vb, vc), less_equal(vp, vq), less(vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), maximum(vp, vq), if_(less_equal(vp, vq), vq, vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), minimum(vp, vq), if_(less_equal(vp, vq), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp), abs(vp), vp));
        result.push_back(data_equation(variable_list(), succ(c1()), cdub(sort_bool::false_(), c1())));
        result.push_back(data_equation(atermpp::make_vector(vp), succ(cdub(sort_bool::false_(), vp)), cdub(sort_bool::true_(), vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), succ(cdub(sort_bool::true_(), vp)), cdub(sort_bool::false_(), succ(vp))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), plus(vp, vq), add_with_carry(sort_bool::false_(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp), add_with_carry(sort_bool::false_(), c1(), vp), succ(vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), add_with_carry(sort_bool::true_(), c1(), vp), succ(succ(vp))));
        result.push_back(data_equation(atermpp::make_vector(vp), add_with_carry(sort_bool::false_(), vp, c1()), succ(vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), add_with_carry(sort_bool::true_(), vp, c1()), succ(succ(vp))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vp, vq), add_with_carry(vb, cdub(vc, vp), cdub(vc, vq)), cdub(vb, add_with_carry(vc, vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), add_with_carry(vb, cdub(sort_bool::false_(), vp), cdub(sort_bool::true_(), vq)), cdub(sort_bool::not_(vb), add_with_carry(vb, vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), add_with_carry(vb, cdub(sort_bool::true_(), vp), cdub(sort_bool::false_(), vq)), cdub(sort_bool::not_(vb), add_with_carry(vb, vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(vp, vq), times(vp, vq), multir(sort_bool::false_(), c1(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(vq, vp), times(vp, vq), multir(sort_bool::false_(), c1(), vq, vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), multir(sort_bool::false_(), vp, c1(), vq), vq));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), multir(sort_bool::true_(), vp, c1(), vq), add_with_carry(sort_bool::false_(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq, vr), multir(vb, vp, cdub(sort_bool::false_(), vq), vr), multir(vb, vp, vq, cdub(sort_bool::false_(), vr))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vr), multir(sort_bool::false_(), vp, cdub(sort_bool::true_(), vq), vr), multir(sort_bool::true_(), vr, vq, cdub(sort_bool::false_(), vr))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vr), multir(sort_bool::true_(), vp, cdub(sort_bool::true_(), vq), vr), multir(sort_bool::true_(), add_with_carry(sort_bool::false_(), vp, vr), vq, cdub(sort_bool::false_(), vr))));
        return result;
      }

    }

  }

}
# 35 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h" 1
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/pos.h" 1
# 30 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_nat {

      inline
      core::identifier_string const& nat_name()
      {
        static core::identifier_string nat_name = data::detail::initialise_static_expression(nat_name, core::identifier_string("Nat"));
        return nat_name;
      }



      inline
      basic_sort const& nat()
      {
        static basic_sort nat = data::detail::initialise_static_expression(nat, basic_sort(nat_name()));
        return nat;
      }




      inline
      bool is_nat(const sort_expression& e)
      {
        if (is_basic_sort(e))
        {
          return basic_sort(e) == nat();
        }
        return false;
      }

      inline
      core::identifier_string const& natpair_name()
      {
        static core::identifier_string natpair_name = data::detail::initialise_static_expression(natpair_name, core::identifier_string("@NatPair"));
        return natpair_name;
      }



      inline
      basic_sort const& natpair()
      {
        static basic_sort natpair = data::detail::initialise_static_expression(natpair, basic_sort(natpair_name()));
        return natpair;
      }




      inline
      bool is_natpair(const sort_expression& e)
      {
        if (is_basic_sort(e))
        {
          return basic_sort(e) == natpair();
        }
        return false;
      }



      inline
      core::identifier_string const& c0_name()
      {
        static core::identifier_string c0_name = data::detail::initialise_static_expression(c0_name, core::identifier_string("@c0"));
        return c0_name;
      }



      inline
      function_symbol const& c0()
      {
        static function_symbol c0 = data::detail::initialise_static_expression(c0, function_symbol(c0_name(), nat()));
        return c0;
      }





      inline
      bool is_c0_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == c0();
        }
        return false;
      }



      inline
      core::identifier_string const& cnat_name()
      {
        static core::identifier_string cnat_name = data::detail::initialise_static_expression(cnat_name, core::identifier_string("@cNat"));
        return cnat_name;
      }



      inline
      function_symbol const& cnat()
      {
        static function_symbol cnat = data::detail::initialise_static_expression(cnat, function_symbol(cnat_name(), make_function_sort(sort_pos::pos(), nat())));
        return cnat;
      }





      inline
      bool is_cnat_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == cnat();
        }
        return false;
      }




      inline
      application cnat(const data_expression& arg0)
      {
        return cnat()(arg0);
      }





      inline
      bool is_cnat_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_cnat_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& cpair_name()
      {
        static core::identifier_string cpair_name = data::detail::initialise_static_expression(cpair_name, core::identifier_string("@cPair"));
        return cpair_name;
      }



      inline
      function_symbol const& cpair()
      {
        static function_symbol cpair = data::detail::initialise_static_expression(cpair, function_symbol(cpair_name(), make_function_sort(nat(), nat(), natpair())));
        return cpair;
      }





      inline
      bool is_cpair_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == cpair();
        }
        return false;
      }





      inline
      application cpair(const data_expression& arg0, const data_expression& arg1)
      {
        return cpair()(arg0, arg1);
      }





      inline
      bool is_cpair_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_cpair_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector nat_generate_constructors_code()
      {
        function_symbol_vector result;
        result.push_back(c0());
        result.push_back(cnat());
        result.push_back(cpair());

        return result;
      }


      inline
      core::identifier_string const& pos2nat_name()
      {
        static core::identifier_string pos2nat_name = data::detail::initialise_static_expression(pos2nat_name, core::identifier_string("Pos2Nat"));
        return pos2nat_name;
      }



      inline
      function_symbol const& pos2nat()
      {
        static function_symbol pos2nat = data::detail::initialise_static_expression(pos2nat, function_symbol(pos2nat_name(), make_function_sort(sort_pos::pos(), nat())));
        return pos2nat;
      }





      inline
      bool is_pos2nat_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == pos2nat();
        }
        return false;
      }




      inline
      application pos2nat(const data_expression& arg0)
      {
        return pos2nat()(arg0);
      }





      inline
      bool is_pos2nat_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_pos2nat_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& nat2pos_name()
      {
        static core::identifier_string nat2pos_name = data::detail::initialise_static_expression(nat2pos_name, core::identifier_string("Nat2Pos"));
        return nat2pos_name;
      }



      inline
      function_symbol const& nat2pos()
      {
        static function_symbol nat2pos = data::detail::initialise_static_expression(nat2pos, function_symbol(nat2pos_name(), make_function_sort(nat(), sort_pos::pos())));
        return nat2pos;
      }





      inline
      bool is_nat2pos_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == nat2pos();
        }
        return false;
      }




      inline
      application nat2pos(const data_expression& arg0)
      {
        return nat2pos()(arg0);
      }





      inline
      bool is_nat2pos_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_nat2pos_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& maximum_name()
      {
        static core::identifier_string maximum_name = data::detail::initialise_static_expression(maximum_name, core::identifier_string("max"));
        return maximum_name;
      }





      inline
      function_symbol maximum(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == sort_pos::pos() && s1 == nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == nat() && s1 == nat())
        {
          target_sort = nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for maximum with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol maximum(maximum_name(), make_function_sort(s0, s1, target_sort));
        return maximum;
      }




      inline
      bool is_maximum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == maximum_name() && function_sort(f.sort()).domain().size() == 2 && (f == maximum(sort_pos::pos(), nat()) || f == maximum(nat(), sort_pos::pos()) || f == maximum(nat(), nat()) || f == maximum(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application maximum(const data_expression& arg0, const data_expression& arg1)
      {
        return maximum(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_maximum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_maximum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& minimum_name()
      {
        static core::identifier_string minimum_name = data::detail::initialise_static_expression(minimum_name, core::identifier_string("min"));
        return minimum_name;
      }





      inline
      function_symbol minimum(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == nat() && s1 == nat())
        {
          target_sort = nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for minimum with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol minimum(minimum_name(), make_function_sort(s0, s1, target_sort));
        return minimum;
      }




      inline
      bool is_minimum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == minimum_name() && function_sort(f.sort()).domain().size() == 2 && (f == minimum(nat(), nat()) || f == minimum(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application minimum(const data_expression& arg0, const data_expression& arg1)
      {
        return minimum(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_minimum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_minimum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& abs_name()
      {
        static core::identifier_string abs_name = data::detail::initialise_static_expression(abs_name, core::identifier_string("abs"));
        return abs_name;
      }




      inline
      function_symbol abs(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == nat())
        {
          target_sort = nat();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for abs with domain sorts " + s0.to_string());
        }

        function_symbol abs(abs_name(), make_function_sort(s0, target_sort));
        return abs;
      }




      inline
      bool is_abs_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == abs_name() && function_sort(f.sort()).domain().size() == 1 && (f == abs(nat()) || f == abs(sort_pos::pos()));
        }
        return false;
      }




      inline
      application abs(const data_expression& arg0)
      {
        return abs(arg0.sort())(arg0);
      }





      inline
      bool is_abs_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_abs_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& succ_name()
      {
        static core::identifier_string succ_name = data::detail::initialise_static_expression(succ_name, core::identifier_string("succ"));
        return succ_name;
      }




      inline
      function_symbol succ(const sort_expression& s0)
      {
        sort_expression target_sort(sort_pos::pos());

        function_symbol succ(succ_name(), make_function_sort(s0, target_sort));
        return succ;
      }




      inline
      bool is_succ_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == succ_name() && function_sort(f.sort()).domain().size() == 1 && (f == succ(nat()) || f == succ(sort_pos::pos()));
        }
        return false;
      }




      inline
      application succ(const data_expression& arg0)
      {
        return succ(arg0.sort())(arg0);
      }





      inline
      bool is_succ_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_succ_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& pred_name()
      {
        static core::identifier_string pred_name = data::detail::initialise_static_expression(pred_name, core::identifier_string("pred"));
        return pred_name;
      }



      inline
      function_symbol const& pred()
      {
        static function_symbol pred = data::detail::initialise_static_expression(pred, function_symbol(pred_name(), make_function_sort(sort_pos::pos(), nat())));
        return pred;
      }





      inline
      bool is_pred_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == pred();
        }
        return false;
      }




      inline
      application pred(const data_expression& arg0)
      {
        return pred()(arg0);
      }





      inline
      bool is_pred_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_pred_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& dub_name()
      {
        static core::identifier_string dub_name = data::detail::initialise_static_expression(dub_name, core::identifier_string("@dub"));
        return dub_name;
      }



      inline
      function_symbol const& dub()
      {
        static function_symbol dub = data::detail::initialise_static_expression(dub, function_symbol(dub_name(), make_function_sort(sort_bool::bool_(), nat(), nat())));
        return dub;
      }





      inline
      bool is_dub_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == dub();
        }
        return false;
      }





      inline
      application dub(const data_expression& arg0, const data_expression& arg1)
      {
        return dub()(arg0, arg1);
      }





      inline
      bool is_dub_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_dub_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& plus_name()
      {
        static core::identifier_string plus_name = data::detail::initialise_static_expression(plus_name, core::identifier_string("+"));
        return plus_name;
      }





      inline
      function_symbol plus(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == sort_pos::pos() && s1 == nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == nat() && s1 == nat())
        {
          target_sort = nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for plus with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol plus(plus_name(), make_function_sort(s0, s1, target_sort));
        return plus;
      }




      inline
      bool is_plus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == plus_name() && function_sort(f.sort()).domain().size() == 2 && (f == plus(sort_pos::pos(), nat()) || f == plus(nat(), sort_pos::pos()) || f == plus(nat(), nat()) || f == plus(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application plus(const data_expression& arg0, const data_expression& arg1)
      {
        return plus(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_plus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_plus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& gtesubt_name()
      {
        static core::identifier_string gtesubt_name = data::detail::initialise_static_expression(gtesubt_name, core::identifier_string("@gtesubt"));
        return gtesubt_name;
      }





      inline
      function_symbol gtesubt(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort(nat());

        function_symbol gtesubt(gtesubt_name(), make_function_sort(s0, s1, target_sort));
        return gtesubt;
      }




      inline
      bool is_gtesubt_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == gtesubt_name() && function_sort(f.sort()).domain().size() == 2 && (f == gtesubt(sort_pos::pos(), sort_pos::pos()) || f == gtesubt(nat(), nat()));
        }
        return false;
      }





      inline
      application gtesubt(const data_expression& arg0, const data_expression& arg1)
      {
        return gtesubt(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_gtesubt_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_gtesubt_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& gtesubtb_name()
      {
        static core::identifier_string gtesubtb_name = data::detail::initialise_static_expression(gtesubtb_name, core::identifier_string("@gtesubtb"));
        return gtesubtb_name;
      }



      inline
      function_symbol const& gtesubtb()
      {
        static function_symbol gtesubtb = data::detail::initialise_static_expression(gtesubtb, function_symbol(gtesubtb_name(), make_function_sort(sort_bool::bool_(), sort_pos::pos(), sort_pos::pos(), nat())));
        return gtesubtb;
      }





      inline
      bool is_gtesubtb_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == gtesubtb();
        }
        return false;
      }






      inline
      application gtesubtb(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return gtesubtb()(arg0, arg1, arg2);
      }





      inline
      bool is_gtesubtb_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_gtesubtb_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& times_name()
      {
        static core::identifier_string times_name = data::detail::initialise_static_expression(times_name, core::identifier_string("*"));
        return times_name;
      }





      inline
      function_symbol times(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == nat() && s1 == nat())
        {
          target_sort = nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for times with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol times(times_name(), make_function_sort(s0, s1, target_sort));
        return times;
      }




      inline
      bool is_times_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == times_name() && function_sort(f.sort()).domain().size() == 2 && (f == times(nat(), nat()) || f == times(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application times(const data_expression& arg0, const data_expression& arg1)
      {
        return times(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_times_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_times_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& div_name()
      {
        static core::identifier_string div_name = data::detail::initialise_static_expression(div_name, core::identifier_string("div"));
        return div_name;
      }





      inline
      function_symbol div(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort(nat());

        function_symbol div(div_name(), make_function_sort(s0, s1, target_sort));
        return div;
      }




      inline
      bool is_div_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == div_name() && function_sort(f.sort()).domain().size() == 2 && (f == div(sort_pos::pos(), sort_pos::pos()) || f == div(nat(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application div(const data_expression& arg0, const data_expression& arg1)
      {
        return div(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_div_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_div_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& mod_name()
      {
        static core::identifier_string mod_name = data::detail::initialise_static_expression(mod_name, core::identifier_string("mod"));
        return mod_name;
      }





      inline
      function_symbol mod(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort(nat());

        function_symbol mod(mod_name(), make_function_sort(s0, s1, target_sort));
        return mod;
      }




      inline
      bool is_mod_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == mod_name() && function_sort(f.sort()).domain().size() == 2 && (f == mod(sort_pos::pos(), sort_pos::pos()) || f == mod(nat(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application mod(const data_expression& arg0, const data_expression& arg1)
      {
        return mod(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_mod_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_mod_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& exp_name()
      {
        static core::identifier_string exp_name = data::detail::initialise_static_expression(exp_name, core::identifier_string("exp"));
        return exp_name;
      }





      inline
      function_symbol exp(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == sort_pos::pos() && s1 == nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == nat() && s1 == nat())
        {
          target_sort = nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for exp with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol exp(exp_name(), make_function_sort(s0, s1, target_sort));
        return exp;
      }




      inline
      bool is_exp_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == exp_name() && function_sort(f.sort()).domain().size() == 2 && (f == exp(sort_pos::pos(), nat()) || f == exp(nat(), nat()));
        }
        return false;
      }





      inline
      application exp(const data_expression& arg0, const data_expression& arg1)
      {
        return exp(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_exp_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_exp_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& even_name()
      {
        static core::identifier_string even_name = data::detail::initialise_static_expression(even_name, core::identifier_string("@even"));
        return even_name;
      }



      inline
      function_symbol const& even()
      {
        static function_symbol even = data::detail::initialise_static_expression(even, function_symbol(even_name(), make_function_sort(nat(), sort_bool::bool_())));
        return even;
      }





      inline
      bool is_even_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == even();
        }
        return false;
      }




      inline
      application even(const data_expression& arg0)
      {
        return even()(arg0);
      }





      inline
      bool is_even_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_even_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& monus_name()
      {
        static core::identifier_string monus_name = data::detail::initialise_static_expression(monus_name, core::identifier_string("@monus"));
        return monus_name;
      }



      inline
      function_symbol const& monus()
      {
        static function_symbol monus = data::detail::initialise_static_expression(monus, function_symbol(monus_name(), make_function_sort(nat(), nat(), nat())));
        return monus;
      }





      inline
      bool is_monus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == monus();
        }
        return false;
      }





      inline
      application monus(const data_expression& arg0, const data_expression& arg1)
      {
        return monus()(arg0, arg1);
      }





      inline
      bool is_monus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_monus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& swap_zero_name()
      {
        static core::identifier_string swap_zero_name = data::detail::initialise_static_expression(swap_zero_name, core::identifier_string("@swap_zero"));
        return swap_zero_name;
      }



      inline
      function_symbol const& swap_zero()
      {
        static function_symbol swap_zero = data::detail::initialise_static_expression(swap_zero, function_symbol(swap_zero_name(), make_function_sort(nat(), nat(), nat())));
        return swap_zero;
      }





      inline
      bool is_swap_zero_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == swap_zero();
        }
        return false;
      }





      inline
      application swap_zero(const data_expression& arg0, const data_expression& arg1)
      {
        return swap_zero()(arg0, arg1);
      }





      inline
      bool is_swap_zero_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_swap_zero_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& swap_zero_add_name()
      {
        static core::identifier_string swap_zero_add_name = data::detail::initialise_static_expression(swap_zero_add_name, core::identifier_string("@swap_zero_add"));
        return swap_zero_add_name;
      }



      inline
      function_symbol const& swap_zero_add()
      {
        static function_symbol swap_zero_add = data::detail::initialise_static_expression(swap_zero_add, function_symbol(swap_zero_add_name(), make_function_sort(nat(), nat(), nat(), nat(), nat())));
        return swap_zero_add;
      }





      inline
      bool is_swap_zero_add_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == swap_zero_add();
        }
        return false;
      }







      inline
      application swap_zero_add(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return swap_zero_add()(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_swap_zero_add_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_swap_zero_add_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& swap_zero_min_name()
      {
        static core::identifier_string swap_zero_min_name = data::detail::initialise_static_expression(swap_zero_min_name, core::identifier_string("@swap_zero_min"));
        return swap_zero_min_name;
      }



      inline
      function_symbol const& swap_zero_min()
      {
        static function_symbol swap_zero_min = data::detail::initialise_static_expression(swap_zero_min, function_symbol(swap_zero_min_name(), make_function_sort(nat(), nat(), nat(), nat(), nat())));
        return swap_zero_min;
      }





      inline
      bool is_swap_zero_min_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == swap_zero_min();
        }
        return false;
      }







      inline
      application swap_zero_min(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return swap_zero_min()(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_swap_zero_min_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_swap_zero_min_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& swap_zero_monus_name()
      {
        static core::identifier_string swap_zero_monus_name = data::detail::initialise_static_expression(swap_zero_monus_name, core::identifier_string("@swap_zero_monus"));
        return swap_zero_monus_name;
      }



      inline
      function_symbol const& swap_zero_monus()
      {
        static function_symbol swap_zero_monus = data::detail::initialise_static_expression(swap_zero_monus, function_symbol(swap_zero_monus_name(), make_function_sort(nat(), nat(), nat(), nat(), nat())));
        return swap_zero_monus;
      }





      inline
      bool is_swap_zero_monus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == swap_zero_monus();
        }
        return false;
      }







      inline
      application swap_zero_monus(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return swap_zero_monus()(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_swap_zero_monus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_swap_zero_monus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& swap_zero_lte_name()
      {
        static core::identifier_string swap_zero_lte_name = data::detail::initialise_static_expression(swap_zero_lte_name, core::identifier_string("@swap_zero_lte"));
        return swap_zero_lte_name;
      }



      inline
      function_symbol const& swap_zero_lte()
      {
        static function_symbol swap_zero_lte = data::detail::initialise_static_expression(swap_zero_lte, function_symbol(swap_zero_lte_name(), make_function_sort(nat(), nat(), nat(), sort_bool::bool_())));
        return swap_zero_lte;
      }





      inline
      bool is_swap_zero_lte_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == swap_zero_lte();
        }
        return false;
      }






      inline
      application swap_zero_lte(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return swap_zero_lte()(arg0, arg1, arg2);
      }





      inline
      bool is_swap_zero_lte_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_swap_zero_lte_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& first_name()
      {
        static core::identifier_string first_name = data::detail::initialise_static_expression(first_name, core::identifier_string("@first"));
        return first_name;
      }



      inline
      function_symbol const& first()
      {
        static function_symbol first = data::detail::initialise_static_expression(first, function_symbol(first_name(), make_function_sort(natpair(), nat())));
        return first;
      }





      inline
      bool is_first_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == first();
        }
        return false;
      }




      inline
      application first(const data_expression& arg0)
      {
        return first()(arg0);
      }





      inline
      bool is_first_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_first_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& last_name()
      {
        static core::identifier_string last_name = data::detail::initialise_static_expression(last_name, core::identifier_string("@last"));
        return last_name;
      }



      inline
      function_symbol const& last()
      {
        static function_symbol last = data::detail::initialise_static_expression(last, function_symbol(last_name(), make_function_sort(natpair(), nat())));
        return last;
      }





      inline
      bool is_last_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == last();
        }
        return false;
      }




      inline
      application last(const data_expression& arg0)
      {
        return last()(arg0);
      }





      inline
      bool is_last_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_last_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& divmod_name()
      {
        static core::identifier_string divmod_name = data::detail::initialise_static_expression(divmod_name, core::identifier_string("@divmod"));
        return divmod_name;
      }



      inline
      function_symbol const& divmod()
      {
        static function_symbol divmod = data::detail::initialise_static_expression(divmod, function_symbol(divmod_name(), make_function_sort(sort_pos::pos(), sort_pos::pos(), natpair())));
        return divmod;
      }





      inline
      bool is_divmod_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == divmod();
        }
        return false;
      }





      inline
      application divmod(const data_expression& arg0, const data_expression& arg1)
      {
        return divmod()(arg0, arg1);
      }





      inline
      bool is_divmod_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_divmod_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& gdivmod_name()
      {
        static core::identifier_string gdivmod_name = data::detail::initialise_static_expression(gdivmod_name, core::identifier_string("@gdivmod"));
        return gdivmod_name;
      }



      inline
      function_symbol const& gdivmod()
      {
        static function_symbol gdivmod = data::detail::initialise_static_expression(gdivmod, function_symbol(gdivmod_name(), make_function_sort(natpair(), sort_bool::bool_(), sort_pos::pos(), natpair())));
        return gdivmod;
      }





      inline
      bool is_gdivmod_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == gdivmod();
        }
        return false;
      }






      inline
      application gdivmod(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return gdivmod()(arg0, arg1, arg2);
      }





      inline
      bool is_gdivmod_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_gdivmod_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& ggdivmod_name()
      {
        static core::identifier_string ggdivmod_name = data::detail::initialise_static_expression(ggdivmod_name, core::identifier_string("@ggdivmod"));
        return ggdivmod_name;
      }



      inline
      function_symbol const& ggdivmod()
      {
        static function_symbol ggdivmod = data::detail::initialise_static_expression(ggdivmod, function_symbol(ggdivmod_name(), make_function_sort(nat(), nat(), sort_pos::pos(), natpair())));
        return ggdivmod;
      }





      inline
      bool is_ggdivmod_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == ggdivmod();
        }
        return false;
      }






      inline
      application ggdivmod(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return ggdivmod()(arg0, arg1, arg2);
      }





      inline
      bool is_ggdivmod_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_ggdivmod_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector nat_generate_functions_code()
      {
        function_symbol_vector result;
        result.push_back(pos2nat());
        result.push_back(nat2pos());
        result.push_back(maximum(sort_pos::pos(), nat()));
        result.push_back(maximum(nat(), sort_pos::pos()));
        result.push_back(maximum(nat(), nat()));
        result.push_back(minimum(nat(), nat()));
        result.push_back(abs(nat()));
        result.push_back(succ(nat()));
        result.push_back(pred());
        result.push_back(dub());
        result.push_back(plus(sort_pos::pos(), nat()));
        result.push_back(plus(nat(), sort_pos::pos()));
        result.push_back(plus(nat(), nat()));
        result.push_back(gtesubt(sort_pos::pos(), sort_pos::pos()));
        result.push_back(gtesubt(nat(), nat()));
        result.push_back(gtesubtb());
        result.push_back(times(nat(), nat()));
        result.push_back(div(sort_pos::pos(), sort_pos::pos()));
        result.push_back(div(nat(), sort_pos::pos()));
        result.push_back(mod(sort_pos::pos(), sort_pos::pos()));
        result.push_back(mod(nat(), sort_pos::pos()));
        result.push_back(exp(sort_pos::pos(), nat()));
        result.push_back(exp(nat(), nat()));
        result.push_back(even());
        result.push_back(monus());
        result.push_back(swap_zero());
        result.push_back(swap_zero_add());
        result.push_back(swap_zero_min());
        result.push_back(swap_zero_monus());
        result.push_back(swap_zero_lte());
        result.push_back(first());
        result.push_back(last());
        result.push_back(divmod());
        result.push_back(gdivmod());
        result.push_back(ggdivmod());
        return result;
      }





      inline
      data_expression right(const data_expression& e)
      {
        ((is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_times_application(e) || is_monus_application(e) || is_swap_zero_application(e)) ? static_cast<void> (0) : __assert_fail ("is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_times_application(e) || is_monus_application(e) || is_swap_zero_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 1942, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression proj2(const data_expression& e)
      {
        ((is_cpair_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cpair_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 1954, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression proj1(const data_expression& e)
      {
        ((is_cpair_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cpair_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 1966, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_gtesubt_application(e) || is_gtesubtb_application(e) || is_div_application(e) || is_mod_application(e) || is_exp_application(e) || is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_divmod_application(e) || is_gdivmod_application(e) || is_ggdivmod_application(e)) ? static_cast<void> (0) : __assert_fail ("is_gtesubt_application(e) || is_gtesubtb_application(e) || is_div_application(e) || is_mod_application(e) || is_exp_application(e) || is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_divmod_application(e) || is_gdivmod_application(e) || is_ggdivmod_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 1978, __PRETTY_FUNCTION__));
        if (is_gtesubt_application(e) || is_div_application(e) || is_mod_application(e) || is_exp_application(e) || is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_divmod_application(e) || is_gdivmod_application(e) || is_ggdivmod_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 0);
        }
        if (is_gtesubtb_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_gtesubt_application(e) || is_gtesubtb_application(e) || is_div_application(e) || is_mod_application(e) || is_exp_application(e) || is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_divmod_application(e) || is_ggdivmod_application(e)) ? static_cast<void> (0) : __assert_fail ("is_gtesubt_application(e) || is_gtesubtb_application(e) || is_div_application(e) || is_mod_application(e) || is_exp_application(e) || is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_divmod_application(e) || is_ggdivmod_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 1998, __PRETTY_FUNCTION__));
        if (is_gtesubt_application(e) || is_div_application(e) || is_mod_application(e) || is_exp_application(e) || is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_divmod_application(e) || is_ggdivmod_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        if (is_gtesubtb_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 2);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression arg3(const data_expression& e)
      {
        ((is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_gdivmod_application(e) || is_ggdivmod_application(e)) ? static_cast<void> (0) : __assert_fail ("is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e) || is_swap_zero_lte_application(e) || is_gdivmod_application(e) || is_ggdivmod_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2018, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }






      inline
      data_expression arg4(const data_expression& e)
      {
        ((is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e)) ? static_cast<void> (0) : __assert_fail ("is_swap_zero_add_application(e) || is_swap_zero_min_application(e) || is_swap_zero_monus_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2030, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 3);
      }






      inline
      data_expression number(const data_expression& e)
      {
        ((is_abs_application(e) || is_succ_application(e) || is_pred_application(e)) ? static_cast<void> (0) : __assert_fail ("is_abs_application(e) || is_succ_application(e) || is_pred_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2042, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_cnat_application(e) || is_pos2nat_application(e) || is_nat2pos_application(e) || is_dub_application(e) || is_even_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cnat_application(e) || is_pos2nat_application(e) || is_nat2pos_application(e) || is_dub_application(e) || is_even_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2054, __PRETTY_FUNCTION__));
        if (is_cnat_application(e) || is_pos2nat_application(e) || is_nat2pos_application(e) || is_even_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 0);
        }
        if (is_dub_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression pair(const data_expression& e)
      {
        ((is_first_application(e) || is_last_application(e)) ? static_cast<void> (0) : __assert_fail ("is_first_application(e) || is_last_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2074, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression bit(const data_expression& e)
      {
        ((is_dub_application(e) || is_gtesubtb_application(e) || is_gdivmod_application(e)) ? static_cast<void> (0) : __assert_fail ("is_dub_application(e) || is_gtesubtb_application(e) || is_gdivmod_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2086, __PRETTY_FUNCTION__));
        if (is_dub_application(e) || is_gtesubtb_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 0);
        }
        if (is_gdivmod_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_times_application(e) || is_monus_application(e) || is_swap_zero_application(e)) ? static_cast<void> (0) : __assert_fail ("is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_times_application(e) || is_monus_application(e) || is_swap_zero_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h", 2106, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }



      inline
      data_equation_vector nat_generate_equations_code()
      {
        variable vb("b",sort_bool::bool_());
        variable vc("c",sort_bool::bool_());
        variable vp("p",sort_pos::pos());
        variable vq("q",sort_pos::pos());
        variable vn("n",nat());
        variable vm("m",nat());
        variable vu("u",nat());
        variable vv("v",nat());

        data_equation_vector result;
        result.push_back(data_equation(atermpp::make_vector(vp), equal_to(c0(), cnat(vp)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp), equal_to(cnat(vp), c0()), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), equal_to(cnat(vp), cnat(vq)), equal_to(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vn), less(vn, c0()), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp), less(c0(), cnat(vp)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(cnat(vp), cnat(vq)), less(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vn), less_equal(c0(), vn), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vp), less_equal(cnat(vp), c0()), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(cnat(vp), cnat(vq)), less_equal(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp), pos2nat(vp), cnat(vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), nat2pos(cnat(vp)), vp));
        result.push_back(data_equation(atermpp::make_vector(vp), maximum(vp, c0()), vp));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), maximum(vp, cnat(vq)), if_(less_equal(vp, vq), vq, vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), maximum(c0(), vp), vp));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), maximum(cnat(vp), vq), if_(less_equal(vp, vq), vq, vp)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), maximum(vm, vn), if_(less_equal(vm, vn), vn, vm)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), minimum(vm, vn), if_(less_equal(vm, vn), vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vn), abs(vn), vn));
        result.push_back(data_equation(variable_list(), succ(c0()), sort_pos::c1()));
        result.push_back(data_equation(atermpp::make_vector(vp), succ(cnat(vp)), succ(vp)));
        result.push_back(data_equation(atermpp::make_vector(vn), succ(succ(vn)), sort_pos::cdub(equal_to(mod(vn, sort_pos::cdub(sort_bool::false_(), sort_pos::c1())), cnat(sort_pos::c1())), succ(div(vn, sort_pos::cdub(sort_bool::false_(), sort_pos::c1()))))));
        result.push_back(data_equation(variable_list(), pred(sort_pos::c1()), c0()));
        result.push_back(data_equation(atermpp::make_vector(vp), pred(sort_pos::cdub(sort_bool::true_(), vp)), cnat(sort_pos::cdub(sort_bool::false_(), vp))));
        result.push_back(data_equation(atermpp::make_vector(vp), pred(sort_pos::cdub(sort_bool::false_(), vp)), dub(sort_bool::true_(), pred(vp))));
        result.push_back(data_equation(variable_list(), dub(sort_bool::false_(), c0()), c0()));
        result.push_back(data_equation(variable_list(), dub(sort_bool::true_(), c0()), cnat(sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), dub(vb, cnat(vp)), cnat(sort_pos::cdub(vb, vp))));
        result.push_back(data_equation(atermpp::make_vector(vp), plus(vp, c0()), vp));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), plus(vp, cnat(vq)), sort_pos::add_with_carry(sort_bool::false_(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp), plus(c0(), vp), vp));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), plus(cnat(vp), vq), sort_pos::add_with_carry(sort_bool::false_(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vn), plus(c0(), vn), vn));
        result.push_back(data_equation(atermpp::make_vector(vn), plus(vn, c0()), vn));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), plus(cnat(vp), cnat(vq)), cnat(sort_pos::add_with_carry(sort_bool::false_(), vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), gtesubt(vp, vq), gtesubtb(sort_bool::false_(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vn), gtesubt(vn, c0()), vn));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), gtesubt(cnat(vp), cnat(vq)), gtesubtb(sort_bool::false_(), vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp), gtesubtb(sort_bool::false_(), vp, sort_pos::c1()), pred(vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), gtesubtb(sort_bool::true_(), vp, sort_pos::c1()), pred(nat2pos(pred(vp)))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vp, vq), gtesubtb(vb, sort_pos::cdub(vc, vp), sort_pos::cdub(vc, vq)), dub(vb, gtesubtb(vb, vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), gtesubtb(vb, sort_pos::cdub(sort_bool::false_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), dub(sort_bool::not_(vb), gtesubtb(sort_bool::true_(), vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), gtesubtb(vb, sort_pos::cdub(sort_bool::true_(), vp), sort_pos::cdub(sort_bool::false_(), vq)), dub(sort_bool::not_(vb), gtesubtb(sort_bool::false_(), vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vn), times(c0(), vn), c0()));
        result.push_back(data_equation(atermpp::make_vector(vn), times(vn, c0()), c0()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), times(cnat(vp), cnat(vq)), cnat(times(vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp), exp(vp, c0()), sort_pos::c1()));
        result.push_back(data_equation(atermpp::make_vector(vp), exp(vp, cnat(sort_pos::c1())), vp));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), exp(vp, cnat(sort_pos::cdub(sort_bool::false_(), vq))), exp(sort_pos::multir(sort_bool::false_(), sort_pos::c1(), vp, vp), cnat(vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), exp(vp, cnat(sort_pos::cdub(sort_bool::true_(), vq))), sort_pos::multir(sort_bool::false_(), sort_pos::c1(), vp, exp(sort_pos::multir(sort_bool::false_(), sort_pos::c1(), vp, vp), cnat(vq)))));
        result.push_back(data_equation(atermpp::make_vector(vn), exp(vn, c0()), cnat(sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vp), exp(c0(), cnat(vp)), c0()));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), exp(cnat(vp), vn), cnat(exp(vp, vn))));
        result.push_back(data_equation(variable_list(), even(c0()), sort_bool::true_()));
        result.push_back(data_equation(variable_list(), even(cnat(sort_pos::c1())), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), even(cnat(sort_pos::cdub(vb, vp))), sort_bool::not_(vb)));
        result.push_back(data_equation(atermpp::make_vector(vp), div(vp, sort_pos::c1()), cnat(vp)));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), div(sort_pos::c1(), sort_pos::cdub(vb, vp)), c0()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), div(sort_pos::cdub(vb, vp), sort_pos::cdub(sort_bool::false_(), vq)), div(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(vp, vq), div(sort_pos::cdub(sort_bool::false_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), c0()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(vq, vp), div(sort_pos::cdub(sort_bool::false_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), first(gdivmod(divmod(vp, sort_pos::cdub(sort_bool::true_(), vq)), sort_bool::false_(), sort_pos::cdub(sort_bool::true_(), vq)))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(vp, vq), div(sort_pos::cdub(sort_bool::true_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), if_(equal_to(vp, vq), cnat(sort_pos::c1()), c0())));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(vq, vp), div(sort_pos::cdub(sort_bool::true_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), first(gdivmod(divmod(vp, sort_pos::cdub(sort_bool::true_(), vq)), sort_bool::true_(), sort_pos::cdub(sort_bool::true_(), vq)))));
        result.push_back(data_equation(atermpp::make_vector(vp), div(c0(), vp), c0()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), div(cnat(vp), vq), div(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vp), mod(vp, sort_pos::c1()), c0()));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), mod(sort_pos::c1(), sort_pos::cdub(vb, vp)), cnat(sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), mod(sort_pos::cdub(vb, vp), sort_pos::cdub(sort_bool::false_(), vq)), dub(vb, mod(vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(vp, vq), mod(sort_pos::cdub(sort_bool::false_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), cnat(sort_pos::cdub(sort_bool::false_(), vp))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(vq, vp), mod(sort_pos::cdub(sort_bool::false_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), last(gdivmod(divmod(vp, sort_pos::cdub(sort_bool::true_(), vq)), sort_bool::false_(), sort_pos::cdub(sort_bool::true_(), vq)))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(vp, vq), mod(sort_pos::cdub(sort_bool::true_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), if_(equal_to(vp, vq), c0(), cnat(sort_pos::cdub(sort_bool::true_(), vp)))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(vq, vp), mod(sort_pos::cdub(sort_bool::true_(), vp), sort_pos::cdub(sort_bool::true_(), vq)), last(gdivmod(divmod(vp, sort_pos::cdub(sort_bool::true_(), vq)), sort_bool::true_(), sort_pos::cdub(sort_bool::true_(), vq)))));
        result.push_back(data_equation(atermpp::make_vector(vp), mod(c0(), vp), c0()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), mod(cnat(vp), vq), mod(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), less_equal(vm, vn), monus(vm, vn), c0()));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), less(vn, vm), monus(vm, vn), gtesubt(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vm), swap_zero(vm, c0()), vm));
        result.push_back(data_equation(atermpp::make_vector(vn), swap_zero(c0(), vn), vn));
        result.push_back(data_equation(atermpp::make_vector(vp), swap_zero(cnat(vp), cnat(vp)), c0()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), not_equal_to(vp, vq), swap_zero(cnat(vp), cnat(vq)), cnat(vq)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), swap_zero_add(c0(), c0(), vm, vn), plus(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vm, vp), swap_zero_add(cnat(vp), c0(), vm, c0()), vm));
        result.push_back(data_equation(atermpp::make_vector(vm, vp, vq), swap_zero_add(cnat(vp), c0(), vm, cnat(vq)), swap_zero(cnat(vp), plus(swap_zero(cnat(vp), vm), cnat(vq)))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), swap_zero_add(c0(), cnat(vp), c0(), vn), vn));
        result.push_back(data_equation(atermpp::make_vector(vn, vp, vq), swap_zero_add(c0(), cnat(vp), cnat(vq), vn), swap_zero(cnat(vp), plus(cnat(vq), swap_zero(cnat(vp), vn)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vp, vq), swap_zero_add(cnat(vp), cnat(vq), vm, vn), swap_zero(plus(cnat(vp), cnat(vq)), plus(swap_zero(cnat(vp), vm), swap_zero(cnat(vq), vn)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), swap_zero_min(c0(), c0(), vm, vn), minimum(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vm, vp), swap_zero_min(cnat(vp), c0(), vm, c0()), c0()));
        result.push_back(data_equation(atermpp::make_vector(vm, vp, vq), swap_zero_min(cnat(vp), c0(), vm, cnat(vq)), minimum(swap_zero(cnat(vp), vm), cnat(vq))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), swap_zero_min(c0(), cnat(vp), c0(), vn), c0()));
        result.push_back(data_equation(atermpp::make_vector(vn, vp, vq), swap_zero_min(c0(), cnat(vp), cnat(vq), vn), minimum(cnat(vq), swap_zero(cnat(vp), vn))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vp, vq), swap_zero_min(cnat(vp), cnat(vq), vm, vn), swap_zero(minimum(cnat(vp), cnat(vq)), minimum(swap_zero(cnat(vp), vm), swap_zero(cnat(vq), vn)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), swap_zero_monus(c0(), c0(), vm, vn), monus(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vm, vp), swap_zero_monus(cnat(vp), c0(), vm, c0()), vm));
        result.push_back(data_equation(atermpp::make_vector(vm, vp, vq), swap_zero_monus(cnat(vp), c0(), vm, cnat(vq)), swap_zero(cnat(vp), monus(swap_zero(cnat(vp), vm), cnat(vq)))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), swap_zero_monus(c0(), cnat(vp), c0(), vn), c0()));
        result.push_back(data_equation(atermpp::make_vector(vn, vp, vq), swap_zero_monus(c0(), cnat(vp), cnat(vq), vn), monus(cnat(vq), swap_zero(cnat(vp), vn))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vp, vq), swap_zero_monus(cnat(vp), cnat(vq), vm, vn), swap_zero(monus(cnat(vp), cnat(vq)), monus(swap_zero(cnat(vp), vm), swap_zero(cnat(vq), vn)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), swap_zero_lte(c0(), vm, vn), less_equal(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vp), swap_zero_lte(cnat(vp), vm, vn), less_equal(swap_zero(cnat(vp), vm), swap_zero(cnat(vp), vn))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vu, vv), equal_to(cpair(vm, vn), cpair(vu, vv)), sort_bool::and_(equal_to(vm, vu), equal_to(vn, vv))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vu, vv), less(cpair(vm, vn), cpair(vu, vv)), sort_bool::or_(less(vm, vu), sort_bool::and_(equal_to(vm, vu), less(vn, vv)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn, vu, vv), less_equal(cpair(vm, vn), cpair(vu, vv)), sort_bool::or_(less(vm, vu), sort_bool::and_(equal_to(vm, vu), less_equal(vn, vv)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), first(cpair(vm, vn)), vm));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), last(cpair(vm, vn)), vn));
        result.push_back(data_equation(variable_list(), divmod(sort_pos::c1(), sort_pos::c1()), cpair(cnat(sort_pos::c1()), c0())));
        result.push_back(data_equation(atermpp::make_vector(vb, vp), divmod(sort_pos::c1(), sort_pos::cdub(vb, vp)), cpair(c0(), cnat(sort_pos::c1()))));
        result.push_back(data_equation(atermpp::make_vector(vb, vp, vq), divmod(sort_pos::cdub(vb, vp), vq), gdivmod(divmod(vp, vq), vb, vq)));
        result.push_back(data_equation(atermpp::make_vector(vb, vm, vn, vp), gdivmod(cpair(vm, vn), vb, vp), ggdivmod(dub(vb, vn), vm, vp)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), ggdivmod(c0(), vn, vp), cpair(dub(sort_bool::false_(), vn), c0())));
        result.push_back(data_equation(atermpp::make_vector(vn, vp, vq), less(vp, vq), ggdivmod(cnat(vp), vn, vq), cpair(dub(sort_bool::false_(), vn), cnat(vp))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp, vq), less_equal(vq, vp), ggdivmod(cnat(vp), vn, vq), cpair(dub(sort_bool::true_(), vn), gtesubtb(sort_bool::false_(), vp, vq))));
        return result;
      }

    }

  }

}
# 36 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h" 1
# 30 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/nat.h" 1
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_int {

      inline
      core::identifier_string const& int_name()
      {
        static core::identifier_string int_name = data::detail::initialise_static_expression(int_name, core::identifier_string("Int"));
        return int_name;
      }



      inline
      basic_sort const& int_()
      {
        static basic_sort int_ = data::detail::initialise_static_expression(int_, basic_sort(int_name()));
        return int_;
      }




      inline
      bool is_int(const sort_expression& e)
      {
        if (is_basic_sort(e))
        {
          return basic_sort(e) == int_();
        }
        return false;
      }



      inline
      core::identifier_string const& cint_name()
      {
        static core::identifier_string cint_name = data::detail::initialise_static_expression(cint_name, core::identifier_string("@cInt"));
        return cint_name;
      }



      inline
      function_symbol const& cint()
      {
        static function_symbol cint = data::detail::initialise_static_expression(cint, function_symbol(cint_name(), make_function_sort(sort_nat::nat(), int_())));
        return cint;
      }





      inline
      bool is_cint_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == cint();
        }
        return false;
      }




      inline
      application cint(const data_expression& arg0)
      {
        return cint()(arg0);
      }





      inline
      bool is_cint_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_cint_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& cneg_name()
      {
        static core::identifier_string cneg_name = data::detail::initialise_static_expression(cneg_name, core::identifier_string("@cNeg"));
        return cneg_name;
      }



      inline
      function_symbol const& cneg()
      {
        static function_symbol cneg = data::detail::initialise_static_expression(cneg, function_symbol(cneg_name(), make_function_sort(sort_pos::pos(), int_())));
        return cneg;
      }





      inline
      bool is_cneg_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == cneg();
        }
        return false;
      }




      inline
      application cneg(const data_expression& arg0)
      {
        return cneg()(arg0);
      }





      inline
      bool is_cneg_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_cneg_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector int_generate_constructors_code()
      {
        function_symbol_vector result;
        result.push_back(cint());
        result.push_back(cneg());

        return result;
      }


      inline
      core::identifier_string const& nat2int_name()
      {
        static core::identifier_string nat2int_name = data::detail::initialise_static_expression(nat2int_name, core::identifier_string("Nat2Int"));
        return nat2int_name;
      }



      inline
      function_symbol const& nat2int()
      {
        static function_symbol nat2int = data::detail::initialise_static_expression(nat2int, function_symbol(nat2int_name(), make_function_sort(sort_nat::nat(), int_())));
        return nat2int;
      }





      inline
      bool is_nat2int_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == nat2int();
        }
        return false;
      }




      inline
      application nat2int(const data_expression& arg0)
      {
        return nat2int()(arg0);
      }





      inline
      bool is_nat2int_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_nat2int_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& int2nat_name()
      {
        static core::identifier_string int2nat_name = data::detail::initialise_static_expression(int2nat_name, core::identifier_string("Int2Nat"));
        return int2nat_name;
      }



      inline
      function_symbol const& int2nat()
      {
        static function_symbol int2nat = data::detail::initialise_static_expression(int2nat, function_symbol(int2nat_name(), make_function_sort(int_(), sort_nat::nat())));
        return int2nat;
      }





      inline
      bool is_int2nat_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == int2nat();
        }
        return false;
      }




      inline
      application int2nat(const data_expression& arg0)
      {
        return int2nat()(arg0);
      }





      inline
      bool is_int2nat_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_int2nat_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& pos2int_name()
      {
        static core::identifier_string pos2int_name = data::detail::initialise_static_expression(pos2int_name, core::identifier_string("Pos2Int"));
        return pos2int_name;
      }



      inline
      function_symbol const& pos2int()
      {
        static function_symbol pos2int = data::detail::initialise_static_expression(pos2int, function_symbol(pos2int_name(), make_function_sort(sort_pos::pos(), int_())));
        return pos2int;
      }





      inline
      bool is_pos2int_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == pos2int();
        }
        return false;
      }




      inline
      application pos2int(const data_expression& arg0)
      {
        return pos2int()(arg0);
      }





      inline
      bool is_pos2int_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_pos2int_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& int2pos_name()
      {
        static core::identifier_string int2pos_name = data::detail::initialise_static_expression(int2pos_name, core::identifier_string("Int2Pos"));
        return int2pos_name;
      }



      inline
      function_symbol const& int2pos()
      {
        static function_symbol int2pos = data::detail::initialise_static_expression(int2pos, function_symbol(int2pos_name(), make_function_sort(int_(), sort_pos::pos())));
        return int2pos;
      }





      inline
      bool is_int2pos_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == int2pos();
        }
        return false;
      }




      inline
      application int2pos(const data_expression& arg0)
      {
        return int2pos()(arg0);
      }





      inline
      bool is_int2pos_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_int2pos_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& maximum_name()
      {
        static core::identifier_string maximum_name = data::detail::initialise_static_expression(maximum_name, core::identifier_string("max"));
        return maximum_name;
      }





      inline
      function_symbol maximum(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == sort_pos::pos() && s1 == int_())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == int_() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == int_())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == int_() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == int_() && s1 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for maximum with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol maximum(maximum_name(), make_function_sort(s0, s1, target_sort));
        return maximum;
      }




      inline
      bool is_maximum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == maximum_name() && function_sort(f.sort()).domain().size() == 2 && (f == maximum(sort_pos::pos(), int_()) || f == maximum(int_(), sort_pos::pos()) || f == maximum(sort_nat::nat(), int_()) || f == maximum(int_(), sort_nat::nat()) || f == maximum(int_(), int_()) || f == maximum(sort_pos::pos(), sort_nat::nat()) || f == maximum(sort_nat::nat(), sort_pos::pos()) || f == maximum(sort_nat::nat(), sort_nat::nat()) || f == maximum(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application maximum(const data_expression& arg0, const data_expression& arg1)
      {
        return maximum(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_maximum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_maximum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& minimum_name()
      {
        static core::identifier_string minimum_name = data::detail::initialise_static_expression(minimum_name, core::identifier_string("min"));
        return minimum_name;
      }





      inline
      function_symbol minimum(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == int_() && s1 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for minimum with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol minimum(minimum_name(), make_function_sort(s0, s1, target_sort));
        return minimum;
      }




      inline
      bool is_minimum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == minimum_name() && function_sort(f.sort()).domain().size() == 2 && (f == minimum(int_(), int_()) || f == minimum(sort_nat::nat(), sort_nat::nat()) || f == minimum(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application minimum(const data_expression& arg0, const data_expression& arg1)
      {
        return minimum(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_minimum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_minimum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& abs_name()
      {
        static core::identifier_string abs_name = data::detail::initialise_static_expression(abs_name, core::identifier_string("abs"));
        return abs_name;
      }




      inline
      function_symbol abs(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == int_())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for abs with domain sorts " + s0.to_string());
        }

        function_symbol abs(abs_name(), make_function_sort(s0, target_sort));
        return abs;
      }




      inline
      bool is_abs_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == abs_name() && function_sort(f.sort()).domain().size() == 1 && (f == abs(int_()) || f == abs(sort_nat::nat()) || f == abs(sort_pos::pos()));
        }
        return false;
      }




      inline
      application abs(const data_expression& arg0)
      {
        return abs(arg0.sort())(arg0);
      }





      inline
      bool is_abs_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_abs_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& negate_name()
      {
        static core::identifier_string negate_name = data::detail::initialise_static_expression(negate_name, core::identifier_string("-"));
        return negate_name;
      }




      inline
      function_symbol negate(const sort_expression& s0)
      {
        sort_expression target_sort(int_());

        function_symbol negate(negate_name(), make_function_sort(s0, target_sort));
        return negate;
      }




      inline
      bool is_negate_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == negate_name() && function_sort(f.sort()).domain().size() == 1 && (f == negate(sort_pos::pos()) || f == negate(sort_nat::nat()) || f == negate(int_()));
        }
        return false;
      }




      inline
      application negate(const data_expression& arg0)
      {
        return negate(arg0.sort())(arg0);
      }





      inline
      bool is_negate_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_negate_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& succ_name()
      {
        static core::identifier_string succ_name = data::detail::initialise_static_expression(succ_name, core::identifier_string("succ"));
        return succ_name;
      }




      inline
      function_symbol succ(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for succ with domain sorts " + s0.to_string());
        }

        function_symbol succ(succ_name(), make_function_sort(s0, target_sort));
        return succ;
      }




      inline
      bool is_succ_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == succ_name() && function_sort(f.sort()).domain().size() == 1 && (f == succ(int_()) || f == succ(sort_nat::nat()) || f == succ(sort_pos::pos()));
        }
        return false;
      }




      inline
      application succ(const data_expression& arg0)
      {
        return succ(arg0.sort())(arg0);
      }





      inline
      bool is_succ_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_succ_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& pred_name()
      {
        static core::identifier_string pred_name = data::detail::initialise_static_expression(pred_name, core::identifier_string("pred"));
        return pred_name;
      }




      inline
      function_symbol pred(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == sort_nat::nat())
        {
          target_sort = int_();
        }
        else if (s0 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_nat::nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for pred with domain sorts " + s0.to_string());
        }

        function_symbol pred(pred_name(), make_function_sort(s0, target_sort));
        return pred;
      }




      inline
      bool is_pred_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == pred_name() && function_sort(f.sort()).domain().size() == 1 && (f == pred(sort_nat::nat()) || f == pred(int_()) || f == pred(sort_pos::pos()));
        }
        return false;
      }




      inline
      application pred(const data_expression& arg0)
      {
        return pred(arg0.sort())(arg0);
      }





      inline
      bool is_pred_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_pred_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& dub_name()
      {
        static core::identifier_string dub_name = data::detail::initialise_static_expression(dub_name, core::identifier_string("@dub"));
        return dub_name;
      }





      inline
      function_symbol dub(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == sort_bool::bool_() && s1 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_bool::bool_() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for dub with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol dub(dub_name(), make_function_sort(s0, s1, target_sort));
        return dub;
      }




      inline
      bool is_dub_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == dub_name() && function_sort(f.sort()).domain().size() == 2 && (f == dub(sort_bool::bool_(), int_()) || f == dub(sort_bool::bool_(), sort_nat::nat()));
        }
        return false;
      }





      inline
      application dub(const data_expression& arg0, const data_expression& arg1)
      {
        return dub(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_dub_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_dub_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& plus_name()
      {
        static core::identifier_string plus_name = data::detail::initialise_static_expression(plus_name, core::identifier_string("+"));
        return plus_name;
      }





      inline
      function_symbol plus(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == int_() && s1 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for plus with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol plus(plus_name(), make_function_sort(s0, s1, target_sort));
        return plus;
      }




      inline
      bool is_plus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == plus_name() && function_sort(f.sort()).domain().size() == 2 && (f == plus(int_(), int_()) || f == plus(sort_pos::pos(), sort_nat::nat()) || f == plus(sort_nat::nat(), sort_pos::pos()) || f == plus(sort_nat::nat(), sort_nat::nat()) || f == plus(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application plus(const data_expression& arg0, const data_expression& arg1)
      {
        return plus(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_plus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_plus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& minus_name()
      {
        static core::identifier_string minus_name = data::detail::initialise_static_expression(minus_name, core::identifier_string("-"));
        return minus_name;
      }





      inline
      function_symbol minus(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort(int_());

        function_symbol minus(minus_name(), make_function_sort(s0, s1, target_sort));
        return minus;
      }




      inline
      bool is_minus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == minus_name() && function_sort(f.sort()).domain().size() == 2 && (f == minus(sort_pos::pos(), sort_pos::pos()) || f == minus(sort_nat::nat(), sort_nat::nat()) || f == minus(int_(), int_()));
        }
        return false;
      }





      inline
      application minus(const data_expression& arg0, const data_expression& arg1)
      {
        return minus(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_minus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_minus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& times_name()
      {
        static core::identifier_string times_name = data::detail::initialise_static_expression(times_name, core::identifier_string("*"));
        return times_name;
      }





      inline
      function_symbol times(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == int_() && s1 == int_())
        {
          target_sort = int_();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for times with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol times(times_name(), make_function_sort(s0, s1, target_sort));
        return times;
      }




      inline
      bool is_times_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == times_name() && function_sort(f.sort()).domain().size() == 2 && (f == times(int_(), int_()) || f == times(sort_nat::nat(), sort_nat::nat()) || f == times(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application times(const data_expression& arg0, const data_expression& arg1)
      {
        return times(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_times_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_times_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& div_name()
      {
        static core::identifier_string div_name = data::detail::initialise_static_expression(div_name, core::identifier_string("div"));
        return div_name;
      }





      inline
      function_symbol div(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == int_() && s1 == sort_pos::pos())
        {
          target_sort = int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_nat::nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for div with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol div(div_name(), make_function_sort(s0, s1, target_sort));
        return div;
      }




      inline
      bool is_div_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == div_name() && function_sort(f.sort()).domain().size() == 2 && (f == div(int_(), sort_pos::pos()) || f == div(sort_pos::pos(), sort_pos::pos()) || f == div(sort_nat::nat(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application div(const data_expression& arg0, const data_expression& arg1)
      {
        return div(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_div_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_div_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& mod_name()
      {
        static core::identifier_string mod_name = data::detail::initialise_static_expression(mod_name, core::identifier_string("mod"));
        return mod_name;
      }





      inline
      function_symbol mod(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort(sort_nat::nat());

        function_symbol mod(mod_name(), make_function_sort(s0, s1, target_sort));
        return mod;
      }




      inline
      bool is_mod_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == mod_name() && function_sort(f.sort()).domain().size() == 2 && (f == mod(int_(), sort_pos::pos()) || f == mod(sort_pos::pos(), sort_pos::pos()) || f == mod(sort_nat::nat(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application mod(const data_expression& arg0, const data_expression& arg1)
      {
        return mod(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_mod_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_mod_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& exp_name()
      {
        static core::identifier_string exp_name = data::detail::initialise_static_expression(exp_name, core::identifier_string("exp"));
        return exp_name;
      }





      inline
      function_symbol exp(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == int_() && s1 == sort_nat::nat())
        {
          target_sort = int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for exp with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol exp(exp_name(), make_function_sort(s0, s1, target_sort));
        return exp;
      }




      inline
      bool is_exp_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == exp_name() && function_sort(f.sort()).domain().size() == 2 && (f == exp(int_(), sort_nat::nat()) || f == exp(sort_pos::pos(), sort_nat::nat()) || f == exp(sort_nat::nat(), sort_nat::nat()));
        }
        return false;
      }





      inline
      application exp(const data_expression& arg0, const data_expression& arg1)
      {
        return exp(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_exp_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_exp_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector int_generate_functions_code()
      {
        function_symbol_vector result;
        result.push_back(nat2int());
        result.push_back(int2nat());
        result.push_back(pos2int());
        result.push_back(int2pos());
        result.push_back(maximum(sort_pos::pos(), int_()));
        result.push_back(maximum(int_(), sort_pos::pos()));
        result.push_back(maximum(sort_nat::nat(), int_()));
        result.push_back(maximum(int_(), sort_nat::nat()));
        result.push_back(maximum(int_(), int_()));
        result.push_back(minimum(int_(), int_()));
        result.push_back(abs(int_()));
        result.push_back(negate(sort_pos::pos()));
        result.push_back(negate(sort_nat::nat()));
        result.push_back(negate(int_()));
        result.push_back(succ(int_()));
        result.push_back(pred(sort_nat::nat()));
        result.push_back(pred(int_()));
        result.push_back(dub(sort_bool::bool_(), int_()));
        result.push_back(plus(int_(), int_()));
        result.push_back(minus(sort_pos::pos(), sort_pos::pos()));
        result.push_back(minus(sort_nat::nat(), sort_nat::nat()));
        result.push_back(minus(int_(), int_()));
        result.push_back(times(int_(), int_()));
        result.push_back(div(int_(), sort_pos::pos()));
        result.push_back(mod(int_(), sort_pos::pos()));
        result.push_back(exp(int_(), sort_nat::nat()));
        return result;
      }





      inline
      data_expression right(const data_expression& e)
      {
        ((is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e)) ? static_cast<void> (0) : __assert_fail ("is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1411, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_div_application(e) || is_mod_application(e) || is_exp_application(e)) ? static_cast<void> (0) : __assert_fail ("is_div_application(e) || is_mod_application(e) || is_exp_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1423, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_div_application(e) || is_mod_application(e) || is_exp_application(e)) ? static_cast<void> (0) : __assert_fail ("is_div_application(e) || is_mod_application(e) || is_exp_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1435, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression number(const data_expression& e)
      {
        ((is_abs_application(e) || is_succ_application(e) || is_pred_application(e)) ? static_cast<void> (0) : __assert_fail ("is_abs_application(e) || is_succ_application(e) || is_pred_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1447, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_cint_application(e) || is_cneg_application(e) || is_nat2int_application(e) || is_int2nat_application(e) || is_pos2int_application(e) || is_int2pos_application(e) || is_negate_application(e) || is_dub_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cint_application(e) || is_cneg_application(e) || is_nat2int_application(e) || is_int2nat_application(e) || is_pos2int_application(e) || is_int2pos_application(e) || is_negate_application(e) || is_dub_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1459, __PRETTY_FUNCTION__));
        if (is_cint_application(e) || is_cneg_application(e) || is_nat2int_application(e) || is_int2nat_application(e) || is_pos2int_application(e) || is_int2pos_application(e) || is_negate_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 0);
        }
        if (is_dub_application(e))
        {
          return *boost::next(static_cast< application >(e).arguments().begin(), 1);
        }
        throw mcrl2::runtime_error("Unexpected expression occurred");
      }






      inline
      data_expression bit(const data_expression& e)
      {
        ((is_dub_application(e)) ? static_cast<void> (0) : __assert_fail ("is_dub_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1479, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e)) ? static_cast<void> (0) : __assert_fail ("is_maximum_application(e) || is_minimum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h", 1491, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }



      inline
      data_equation_vector int_generate_equations_code()
      {
        variable vb("b",sort_bool::bool_());
        variable vn("n",sort_nat::nat());
        variable vm("m",sort_nat::nat());
        variable vp("p",sort_pos::pos());
        variable vq("q",sort_pos::pos());
        variable vx("x",int_());
        variable vy("y",int_());

        data_equation_vector result;
        result.push_back(data_equation(atermpp::make_vector(vm, vn), equal_to(cint(vm), cint(vn)), equal_to(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), equal_to(cint(vn), cneg(vp)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), equal_to(cneg(vp), cint(vn)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), equal_to(cneg(vp), cneg(vq)), equal_to(vp, vq)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), less(cint(vm), cint(vn)), less(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), less(cint(vn), cneg(vp)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), less(cneg(vp), cint(vn)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(cneg(vp), cneg(vq)), less(vq, vp)));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), less_equal(cint(vm), cint(vn)), less_equal(vm, vn)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), less_equal(cint(vn), cneg(vp)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), less_equal(cneg(vp), cint(vn)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(cneg(vp), cneg(vq)), less_equal(vq, vp)));
        result.push_back(data_equation(atermpp::make_vector(vn), nat2int(vn), cint(vn)));
        result.push_back(data_equation(atermpp::make_vector(vn), int2nat(cint(vn)), vn));
        result.push_back(data_equation(atermpp::make_vector(vp), pos2int(vp), cint(sort_nat::cnat(vp))));
        result.push_back(data_equation(atermpp::make_vector(vn), int2pos(cint(vn)), sort_nat::nat2pos(vn)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), maximum(vp, cint(vn)), maximum(vp, vn)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), maximum(vp, cneg(vq)), vp));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), maximum(cint(vn), vp), maximum(vn, vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), maximum(cneg(vq), vp), vp));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), maximum(vm, cint(vn)), if_(less_equal(vm, vn), vn, vm)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), maximum(vn, cneg(vp)), vn));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), maximum(cint(vm), vn), if_(less_equal(vm, vn), vn, vm)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), maximum(cneg(vp), vn), vn));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), maximum(vx, vy), if_(less_equal(vx, vy), vy, vx)));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), minimum(vx, vy), if_(less_equal(vx, vy), vx, vy)));
        result.push_back(data_equation(atermpp::make_vector(vn), abs(cint(vn)), vn));
        result.push_back(data_equation(atermpp::make_vector(vp), abs(cneg(vp)), sort_nat::cnat(vp)));
        result.push_back(data_equation(atermpp::make_vector(vp), negate(vp), cneg(vp)));
        result.push_back(data_equation(variable_list(), negate(sort_nat::c0()), cint(sort_nat::c0())));
        result.push_back(data_equation(atermpp::make_vector(vp), negate(sort_nat::cnat(vp)), cneg(vp)));
        result.push_back(data_equation(atermpp::make_vector(vn), negate(cint(vn)), negate(vn)));
        result.push_back(data_equation(atermpp::make_vector(vp), negate(cneg(vp)), cint(sort_nat::cnat(vp))));
        result.push_back(data_equation(atermpp::make_vector(vn), succ(cint(vn)), cint(sort_nat::cnat(succ(vn)))));
        result.push_back(data_equation(atermpp::make_vector(vp), succ(cneg(vp)), negate(pred(vp))));
        result.push_back(data_equation(variable_list(), pred(sort_nat::c0()), cneg(sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vp), pred(sort_nat::cnat(vp)), cint(pred(vp))));
        result.push_back(data_equation(atermpp::make_vector(vn), pred(cint(vn)), pred(vn)));
        result.push_back(data_equation(atermpp::make_vector(vp), pred(cneg(vp)), cneg(succ(vp))));
        result.push_back(data_equation(atermpp::make_vector(vb, vn), dub(vb, cint(vn)), cint(dub(vb, vn))));
        result.push_back(data_equation(atermpp::make_vector(vp), dub(sort_bool::false_(), cneg(vp)), cneg(sort_pos::cdub(sort_bool::false_(), vp))));
        result.push_back(data_equation(atermpp::make_vector(vp), dub(sort_bool::true_(), cneg(vp)), negate(dub(sort_bool::true_(), pred(vp)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), plus(cint(vm), cint(vn)), cint(plus(vm, vn))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), plus(cint(vn), cneg(vp)), minus(vn, sort_nat::cnat(vp))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), plus(cneg(vp), cint(vn)), minus(vn, sort_nat::cnat(vp))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), plus(cneg(vp), cneg(vq)), cneg(sort_pos::add_with_carry(sort_bool::false_(), vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less_equal(vq, vp), minus(vp, vq), cint(sort_nat::gtesubtb(sort_bool::false_(), vp, vq))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), less(vp, vq), minus(vp, vq), negate(sort_nat::gtesubtb(sort_bool::false_(), vq, vp))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), less_equal(vn, vm), minus(vm, vn), cint(sort_nat::gtesubt(vm, vn))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), less(vm, vn), minus(vm, vn), negate(sort_nat::gtesubt(vn, vm))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), minus(vx, vy), plus(vx, negate(vy))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), times(cint(vm), cint(vn)), cint(times(vm, vn))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), times(cint(vn), cneg(vp)), negate(times(sort_nat::cnat(vp), vn))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), times(cneg(vp), cint(vn)), negate(times(sort_nat::cnat(vp), vn))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), times(cneg(vp), cneg(vq)), cint(sort_nat::cnat(times(vp, vq)))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), div(cint(vn), vp), cint(div(vn, vp))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), div(cneg(vp), vq), cneg(succ(div(pred(vp), vq)))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), mod(cint(vn), vp), mod(vn, vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), mod(cneg(vp), vq), int2nat(minus(vq, succ(mod(pred(vp), vq))))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), exp(cint(vm), vn), cint(exp(vm, vn))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), sort_nat::even(vn), exp(cneg(vp), vn), cint(sort_nat::cnat(exp(vp, vn)))));
        result.push_back(data_equation(atermpp::make_vector(vn, vp), sort_bool::not_(sort_nat::even(vn)), exp(cneg(vp), vn), cneg(exp(vp, vn))));
        return result;
      }

    }

  }

}
# 37 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h" 1
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/int.h" 1
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_real {

      inline
      core::identifier_string const& real_name()
      {
        static core::identifier_string real_name = data::detail::initialise_static_expression(real_name, core::identifier_string("Real"));
        return real_name;
      }



      inline
      basic_sort const& real_()
      {
        static basic_sort real_ = data::detail::initialise_static_expression(real_, basic_sort(real_name()));
        return real_;
      }




      inline
      bool is_real(const sort_expression& e)
      {
        if (is_basic_sort(e))
        {
          return basic_sort(e) == real_();
        }
        return false;
      }



      inline
      function_symbol_vector real_generate_constructors_code()
      {
        function_symbol_vector result;
        return result;
      }


      inline
      core::identifier_string const& creal_name()
      {
        static core::identifier_string creal_name = data::detail::initialise_static_expression(creal_name, core::identifier_string("@cReal"));
        return creal_name;
      }



      inline
      function_symbol const& creal()
      {
        static function_symbol creal = data::detail::initialise_static_expression(creal, function_symbol(creal_name(), make_function_sort(sort_int::int_(), sort_pos::pos(), real_())));
        return creal;
      }





      inline
      bool is_creal_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == creal();
        }
        return false;
      }





      inline
      application creal(const data_expression& arg0, const data_expression& arg1)
      {
        return creal()(arg0, arg1);
      }





      inline
      bool is_creal_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_creal_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& pos2real_name()
      {
        static core::identifier_string pos2real_name = data::detail::initialise_static_expression(pos2real_name, core::identifier_string("Pos2Real"));
        return pos2real_name;
      }



      inline
      function_symbol const& pos2real()
      {
        static function_symbol pos2real = data::detail::initialise_static_expression(pos2real, function_symbol(pos2real_name(), make_function_sort(sort_pos::pos(), real_())));
        return pos2real;
      }





      inline
      bool is_pos2real_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == pos2real();
        }
        return false;
      }




      inline
      application pos2real(const data_expression& arg0)
      {
        return pos2real()(arg0);
      }





      inline
      bool is_pos2real_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_pos2real_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& nat2real_name()
      {
        static core::identifier_string nat2real_name = data::detail::initialise_static_expression(nat2real_name, core::identifier_string("Nat2Real"));
        return nat2real_name;
      }



      inline
      function_symbol const& nat2real()
      {
        static function_symbol nat2real = data::detail::initialise_static_expression(nat2real, function_symbol(nat2real_name(), make_function_sort(sort_nat::nat(), real_())));
        return nat2real;
      }





      inline
      bool is_nat2real_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == nat2real();
        }
        return false;
      }




      inline
      application nat2real(const data_expression& arg0)
      {
        return nat2real()(arg0);
      }





      inline
      bool is_nat2real_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_nat2real_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& int2real_name()
      {
        static core::identifier_string int2real_name = data::detail::initialise_static_expression(int2real_name, core::identifier_string("Int2Real"));
        return int2real_name;
      }



      inline
      function_symbol const& int2real()
      {
        static function_symbol int2real = data::detail::initialise_static_expression(int2real, function_symbol(int2real_name(), make_function_sort(sort_int::int_(), real_())));
        return int2real;
      }





      inline
      bool is_int2real_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == int2real();
        }
        return false;
      }




      inline
      application int2real(const data_expression& arg0)
      {
        return int2real()(arg0);
      }





      inline
      bool is_int2real_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_int2real_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& real2pos_name()
      {
        static core::identifier_string real2pos_name = data::detail::initialise_static_expression(real2pos_name, core::identifier_string("Real2Pos"));
        return real2pos_name;
      }



      inline
      function_symbol const& real2pos()
      {
        static function_symbol real2pos = data::detail::initialise_static_expression(real2pos, function_symbol(real2pos_name(), make_function_sort(real_(), sort_pos::pos())));
        return real2pos;
      }





      inline
      bool is_real2pos_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == real2pos();
        }
        return false;
      }




      inline
      application real2pos(const data_expression& arg0)
      {
        return real2pos()(arg0);
      }





      inline
      bool is_real2pos_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_real2pos_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& real2nat_name()
      {
        static core::identifier_string real2nat_name = data::detail::initialise_static_expression(real2nat_name, core::identifier_string("Real2Nat"));
        return real2nat_name;
      }



      inline
      function_symbol const& real2nat()
      {
        static function_symbol real2nat = data::detail::initialise_static_expression(real2nat, function_symbol(real2nat_name(), make_function_sort(real_(), sort_nat::nat())));
        return real2nat;
      }





      inline
      bool is_real2nat_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == real2nat();
        }
        return false;
      }




      inline
      application real2nat(const data_expression& arg0)
      {
        return real2nat()(arg0);
      }





      inline
      bool is_real2nat_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_real2nat_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& real2int_name()
      {
        static core::identifier_string real2int_name = data::detail::initialise_static_expression(real2int_name, core::identifier_string("Real2Int"));
        return real2int_name;
      }



      inline
      function_symbol const& real2int()
      {
        static function_symbol real2int = data::detail::initialise_static_expression(real2int, function_symbol(real2int_name(), make_function_sort(real_(), sort_int::int_())));
        return real2int;
      }





      inline
      bool is_real2int_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == real2int();
        }
        return false;
      }




      inline
      application real2int(const data_expression& arg0)
      {
        return real2int()(arg0);
      }





      inline
      bool is_real2int_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_real2int_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& minimum_name()
      {
        static core::identifier_string minimum_name = data::detail::initialise_static_expression(minimum_name, core::identifier_string("min"));
        return minimum_name;
      }





      inline
      function_symbol minimum(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == real_() && s1 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_int::int_() && s1 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for minimum with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol minimum(minimum_name(), make_function_sort(s0, s1, target_sort));
        return minimum;
      }




      inline
      bool is_minimum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == minimum_name() && function_sort(f.sort()).domain().size() == 2 && (f == minimum(real_(), real_()) || f == minimum(sort_int::int_(), sort_int::int_()) || f == minimum(sort_nat::nat(), sort_nat::nat()) || f == minimum(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application minimum(const data_expression& arg0, const data_expression& arg1)
      {
        return minimum(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_minimum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_minimum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& maximum_name()
      {
        static core::identifier_string maximum_name = data::detail::initialise_static_expression(maximum_name, core::identifier_string("max"));
        return maximum_name;
      }





      inline
      function_symbol maximum(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == real_() && s1 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_int::int_())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_int::int_() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_int::int_())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_int::int_() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_int::int_() && s1 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for maximum with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol maximum(maximum_name(), make_function_sort(s0, s1, target_sort));
        return maximum;
      }




      inline
      bool is_maximum_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == maximum_name() && function_sort(f.sort()).domain().size() == 2 && (f == maximum(real_(), real_()) || f == maximum(sort_pos::pos(), sort_int::int_()) || f == maximum(sort_int::int_(), sort_pos::pos()) || f == maximum(sort_nat::nat(), sort_int::int_()) || f == maximum(sort_int::int_(), sort_nat::nat()) || f == maximum(sort_int::int_(), sort_int::int_()) || f == maximum(sort_pos::pos(), sort_nat::nat()) || f == maximum(sort_nat::nat(), sort_pos::pos()) || f == maximum(sort_nat::nat(), sort_nat::nat()) || f == maximum(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application maximum(const data_expression& arg0, const data_expression& arg1)
      {
        return maximum(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_maximum_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_maximum_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& abs_name()
      {
        static core::identifier_string abs_name = data::detail::initialise_static_expression(abs_name, core::identifier_string("abs"));
        return abs_name;
      }




      inline
      function_symbol abs(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_int::int_())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for abs with domain sorts " + s0.to_string());
        }

        function_symbol abs(abs_name(), make_function_sort(s0, target_sort));
        return abs;
      }




      inline
      bool is_abs_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == abs_name() && function_sort(f.sort()).domain().size() == 1 && (f == abs(real_()) || f == abs(sort_int::int_()) || f == abs(sort_nat::nat()) || f == abs(sort_pos::pos()));
        }
        return false;
      }




      inline
      application abs(const data_expression& arg0)
      {
        return abs(arg0.sort())(arg0);
      }





      inline
      bool is_abs_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_abs_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& negate_name()
      {
        static core::identifier_string negate_name = data::detail::initialise_static_expression(negate_name, core::identifier_string("-"));
        return negate_name;
      }




      inline
      function_symbol negate(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_nat::nat())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for negate with domain sorts " + s0.to_string());
        }

        function_symbol negate(negate_name(), make_function_sort(s0, target_sort));
        return negate;
      }




      inline
      bool is_negate_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == negate_name() && function_sort(f.sort()).domain().size() == 1 && (f == negate(real_()) || f == negate(sort_pos::pos()) || f == negate(sort_nat::nat()) || f == negate(sort_int::int_()));
        }
        return false;
      }




      inline
      application negate(const data_expression& arg0)
      {
        return negate(arg0.sort())(arg0);
      }





      inline
      bool is_negate_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_negate_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& succ_name()
      {
        static core::identifier_string succ_name = data::detail::initialise_static_expression(succ_name, core::identifier_string("succ"));
        return succ_name;
      }




      inline
      function_symbol succ(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for succ with domain sorts " + s0.to_string());
        }

        function_symbol succ(succ_name(), make_function_sort(s0, target_sort));
        return succ;
      }




      inline
      bool is_succ_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == succ_name() && function_sort(f.sort()).domain().size() == 1 && (f == succ(real_()) || f == succ(sort_int::int_()) || f == succ(sort_nat::nat()) || f == succ(sort_pos::pos()));
        }
        return false;
      }




      inline
      application succ(const data_expression& arg0)
      {
        return succ(arg0.sort())(arg0);
      }





      inline
      bool is_succ_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_succ_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& pred_name()
      {
        static core::identifier_string pred_name = data::detail::initialise_static_expression(pred_name, core::identifier_string("pred"));
        return pred_name;
      }




      inline
      function_symbol pred(const sort_expression& s0)
      {
        sort_expression target_sort;
        if (s0 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_nat::nat())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_pos::pos())
        {
          target_sort = sort_nat::nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for pred with domain sorts " + s0.to_string());
        }

        function_symbol pred(pred_name(), make_function_sort(s0, target_sort));
        return pred;
      }




      inline
      bool is_pred_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == pred_name() && function_sort(f.sort()).domain().size() == 1 && (f == pred(real_()) || f == pred(sort_nat::nat()) || f == pred(sort_int::int_()) || f == pred(sort_pos::pos()));
        }
        return false;
      }




      inline
      application pred(const data_expression& arg0)
      {
        return pred(arg0.sort())(arg0);
      }





      inline
      bool is_pred_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_pred_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& plus_name()
      {
        static core::identifier_string plus_name = data::detail::initialise_static_expression(plus_name, core::identifier_string("+"));
        return plus_name;
      }





      inline
      function_symbol plus(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == real_() && s1 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_int::int_() && s1 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for plus with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol plus(plus_name(), make_function_sort(s0, s1, target_sort));
        return plus;
      }




      inline
      bool is_plus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == plus_name() && function_sort(f.sort()).domain().size() == 2 && (f == plus(real_(), real_()) || f == plus(sort_int::int_(), sort_int::int_()) || f == plus(sort_pos::pos(), sort_nat::nat()) || f == plus(sort_nat::nat(), sort_pos::pos()) || f == plus(sort_nat::nat(), sort_nat::nat()) || f == plus(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application plus(const data_expression& arg0, const data_expression& arg1)
      {
        return plus(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_plus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_plus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& minus_name()
      {
        static core::identifier_string minus_name = data::detail::initialise_static_expression(minus_name, core::identifier_string("-"));
        return minus_name;
      }





      inline
      function_symbol minus(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == real_() && s1 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_int::int_() && s1 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for minus with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol minus(minus_name(), make_function_sort(s0, s1, target_sort));
        return minus;
      }




      inline
      bool is_minus_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == minus_name() && function_sort(f.sort()).domain().size() == 2 && (f == minus(real_(), real_()) || f == minus(sort_pos::pos(), sort_pos::pos()) || f == minus(sort_nat::nat(), sort_nat::nat()) || f == minus(sort_int::int_(), sort_int::int_()));
        }
        return false;
      }





      inline
      application minus(const data_expression& arg0, const data_expression& arg1)
      {
        return minus(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_minus_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_minus_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& times_name()
      {
        static core::identifier_string times_name = data::detail::initialise_static_expression(times_name, core::identifier_string("*"));
        return times_name;
      }





      inline
      function_symbol times(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == real_() && s1 == real_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_int::int_() && s1 == sort_int::int_())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_pos::pos())
        {
          target_sort = sort_pos::pos();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for times with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol times(times_name(), make_function_sort(s0, s1, target_sort));
        return times;
      }




      inline
      bool is_times_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == times_name() && function_sort(f.sort()).domain().size() == 2 && (f == times(real_(), real_()) || f == times(sort_int::int_(), sort_int::int_()) || f == times(sort_nat::nat(), sort_nat::nat()) || f == times(sort_pos::pos(), sort_pos::pos()));
        }
        return false;
      }





      inline
      application times(const data_expression& arg0, const data_expression& arg1)
      {
        return times(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_times_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_times_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& exp_name()
      {
        static core::identifier_string exp_name = data::detail::initialise_static_expression(exp_name, core::identifier_string("exp"));
        return exp_name;
      }





      inline
      function_symbol exp(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort;
        if (s0 == real_() && s1 == sort_int::int_())
        {
          target_sort = real_();
        }
        else if (s0 == sort_int::int_() && s1 == sort_nat::nat())
        {
          target_sort = sort_int::int_();
        }
        else if (s0 == sort_pos::pos() && s1 == sort_nat::nat())
        {
          target_sort = sort_pos::pos();
        }
        else if (s0 == sort_nat::nat() && s1 == sort_nat::nat())
        {
          target_sort = sort_nat::nat();
        }
        else
        {
          throw mcrl2::runtime_error("cannot compute target sort for exp with domain sorts " + s0.to_string() + ", " + s1.to_string());
        }

        function_symbol exp(exp_name(), make_function_sort(s0, s1, target_sort));
        return exp;
      }




      inline
      bool is_exp_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == exp_name() && function_sort(f.sort()).domain().size() == 2 && (f == exp(real_(), sort_int::int_()) || f == exp(sort_int::int_(), sort_nat::nat()) || f == exp(sort_pos::pos(), sort_nat::nat()) || f == exp(sort_nat::nat(), sort_nat::nat()));
        }
        return false;
      }





      inline
      application exp(const data_expression& arg0, const data_expression& arg1)
      {
        return exp(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_exp_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_exp_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& divides_name()
      {
        static core::identifier_string divides_name = data::detail::initialise_static_expression(divides_name, core::identifier_string("/"));
        return divides_name;
      }





      inline
      function_symbol divides(const sort_expression& s0, const sort_expression& s1)
      {
        sort_expression target_sort(real_());

        function_symbol divides(divides_name(), make_function_sort(s0, s1, target_sort));
        return divides;
      }




      inline
      bool is_divides_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          function_symbol f(e);
          return f.name() == divides_name() && function_sort(f.sort()).domain().size() == 2 && (f == divides(sort_pos::pos(), sort_pos::pos()) || f == divides(sort_nat::nat(), sort_nat::nat()) || f == divides(sort_int::int_(), sort_int::int_()) || f == divides(real_(), real_()));
        }
        return false;
      }





      inline
      application divides(const data_expression& arg0, const data_expression& arg1)
      {
        return divides(arg0.sort(), arg1.sort())(arg0, arg1);
      }





      inline
      bool is_divides_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_divides_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& floor_name()
      {
        static core::identifier_string floor_name = data::detail::initialise_static_expression(floor_name, core::identifier_string("floor"));
        return floor_name;
      }



      inline
      function_symbol const& floor()
      {
        static function_symbol floor = data::detail::initialise_static_expression(floor, function_symbol(floor_name(), make_function_sort(real_(), sort_int::int_())));
        return floor;
      }





      inline
      bool is_floor_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == floor();
        }
        return false;
      }




      inline
      application floor(const data_expression& arg0)
      {
        return floor()(arg0);
      }





      inline
      bool is_floor_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_floor_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& ceil_name()
      {
        static core::identifier_string ceil_name = data::detail::initialise_static_expression(ceil_name, core::identifier_string("ceil"));
        return ceil_name;
      }



      inline
      function_symbol const& ceil()
      {
        static function_symbol ceil = data::detail::initialise_static_expression(ceil, function_symbol(ceil_name(), make_function_sort(real_(), sort_int::int_())));
        return ceil;
      }





      inline
      bool is_ceil_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == ceil();
        }
        return false;
      }




      inline
      application ceil(const data_expression& arg0)
      {
        return ceil()(arg0);
      }





      inline
      bool is_ceil_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_ceil_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& round_name()
      {
        static core::identifier_string round_name = data::detail::initialise_static_expression(round_name, core::identifier_string("round"));
        return round_name;
      }



      inline
      function_symbol const& round()
      {
        static function_symbol round = data::detail::initialise_static_expression(round, function_symbol(round_name(), make_function_sort(real_(), sort_int::int_())));
        return round;
      }





      inline
      bool is_round_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == round();
        }
        return false;
      }




      inline
      application round(const data_expression& arg0)
      {
        return round()(arg0);
      }





      inline
      bool is_round_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_round_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& redfrac_name()
      {
        static core::identifier_string redfrac_name = data::detail::initialise_static_expression(redfrac_name, core::identifier_string("@redfrac"));
        return redfrac_name;
      }



      inline
      function_symbol const& redfrac()
      {
        static function_symbol redfrac = data::detail::initialise_static_expression(redfrac, function_symbol(redfrac_name(), make_function_sort(sort_int::int_(), sort_int::int_(), real_())));
        return redfrac;
      }





      inline
      bool is_redfrac_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == redfrac();
        }
        return false;
      }





      inline
      application redfrac(const data_expression& arg0, const data_expression& arg1)
      {
        return redfrac()(arg0, arg1);
      }





      inline
      bool is_redfrac_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_redfrac_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& redfracwhr_name()
      {
        static core::identifier_string redfracwhr_name = data::detail::initialise_static_expression(redfracwhr_name, core::identifier_string("@redfracwhr"));
        return redfracwhr_name;
      }



      inline
      function_symbol const& redfracwhr()
      {
        static function_symbol redfracwhr = data::detail::initialise_static_expression(redfracwhr, function_symbol(redfracwhr_name(), make_function_sort(sort_pos::pos(), sort_int::int_(), sort_nat::nat(), real_())));
        return redfracwhr;
      }





      inline
      bool is_redfracwhr_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == redfracwhr();
        }
        return false;
      }






      inline
      application redfracwhr(const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return redfracwhr()(arg0, arg1, arg2);
      }





      inline
      bool is_redfracwhr_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_redfracwhr_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& redfrachlp_name()
      {
        static core::identifier_string redfrachlp_name = data::detail::initialise_static_expression(redfrachlp_name, core::identifier_string("@redfrachlp"));
        return redfrachlp_name;
      }



      inline
      function_symbol const& redfrachlp()
      {
        static function_symbol redfrachlp = data::detail::initialise_static_expression(redfrachlp, function_symbol(redfrachlp_name(), make_function_sort(real_(), sort_int::int_(), real_())));
        return redfrachlp;
      }





      inline
      bool is_redfrachlp_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e) == redfrachlp();
        }
        return false;
      }





      inline
      application redfrachlp(const data_expression& arg0, const data_expression& arg1)
      {
        return redfrachlp()(arg0, arg1);
      }





      inline
      bool is_redfrachlp_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_redfrachlp_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      function_symbol_vector real_generate_functions_code()
      {
        function_symbol_vector result;
        result.push_back(creal());
        result.push_back(pos2real());
        result.push_back(nat2real());
        result.push_back(int2real());
        result.push_back(real2pos());
        result.push_back(real2nat());
        result.push_back(real2int());
        result.push_back(minimum(real_(), real_()));
        result.push_back(maximum(real_(), real_()));
        result.push_back(abs(real_()));
        result.push_back(negate(real_()));
        result.push_back(succ(real_()));
        result.push_back(pred(real_()));
        result.push_back(plus(real_(), real_()));
        result.push_back(minus(real_(), real_()));
        result.push_back(times(real_(), real_()));
        result.push_back(exp(real_(), sort_int::int_()));
        result.push_back(divides(sort_pos::pos(), sort_pos::pos()));
        result.push_back(divides(sort_nat::nat(), sort_nat::nat()));
        result.push_back(divides(sort_int::int_(), sort_int::int_()));
        result.push_back(divides(real_(), real_()));
        result.push_back(floor());
        result.push_back(ceil());
        result.push_back(round());
        result.push_back(redfrac());
        result.push_back(redfracwhr());
        result.push_back(redfrachlp());
        return result;
      }





      inline
      data_expression right(const data_expression& e)
      {
        ((is_minimum_application(e) || is_maximum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e) || is_exp_application(e) || is_divides_application(e) || is_redfrachlp_application(e)) ? static_cast<void> (0) : __assert_fail ("is_minimum_application(e) || is_maximum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e) || is_exp_application(e) || is_divides_application(e) || is_redfrachlp_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1724, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg3(const data_expression& e)
      {
        ((is_redfracwhr_application(e)) ? static_cast<void> (0) : __assert_fail ("is_redfracwhr_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1736, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_redfracwhr_application(e)) ? static_cast<void> (0) : __assert_fail ("is_redfracwhr_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1748, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_redfracwhr_application(e)) ? static_cast<void> (0) : __assert_fail ("is_redfracwhr_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1760, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression denominator(const data_expression& e)
      {
        ((is_creal_application(e)) ? static_cast<void> (0) : __assert_fail ("is_creal_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1772, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression numerator(const data_expression& e)
      {
        ((is_creal_application(e)) ? static_cast<void> (0) : __assert_fail ("is_creal_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1784, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_pos2real_application(e) || is_nat2real_application(e) || is_int2real_application(e) || is_real2pos_application(e) || is_real2nat_application(e) || is_real2int_application(e) || is_abs_application(e) || is_negate_application(e) || is_succ_application(e) || is_pred_application(e) || is_floor_application(e) || is_ceil_application(e) || is_round_application(e)) ? static_cast<void> (0) : __assert_fail ("is_pos2real_application(e) || is_nat2real_application(e) || is_int2real_application(e) || is_real2pos_application(e) || is_real2nat_application(e) || is_real2int_application(e) || is_abs_application(e) || is_negate_application(e) || is_succ_application(e) || is_pred_application(e) || is_floor_application(e) || is_ceil_application(e) || is_round_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1796, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_minimum_application(e) || is_maximum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e) || is_exp_application(e) || is_divides_application(e) || is_redfrachlp_application(e)) ? static_cast<void> (0) : __assert_fail ("is_minimum_application(e) || is_maximum_application(e) || is_plus_application(e) || is_minus_application(e) || is_times_application(e) || is_exp_application(e) || is_divides_application(e) || is_redfrachlp_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h", 1808, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }



      inline
      data_equation_vector real_generate_equations_code()
      {
        variable vm("m",sort_nat::nat());
        variable vn("n",sort_nat::nat());
        variable vp("p",sort_pos::pos());
        variable vq("q",sort_pos::pos());
        variable vx("x",sort_int::int_());
        variable vy("y",sort_int::int_());
        variable vr("r",real_());
        variable vs("s",real_());

        data_equation_vector result;
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), equal_to(creal(vx, vp), creal(vy, vq)), equal_to(times(vx, sort_int::cint(sort_nat::cnat(vq))), times(vy, sort_int::cint(sort_nat::cnat(vp))))));
        result.push_back(data_equation(atermpp::make_vector(vr), less(vr, vr), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), less(creal(vx, vp), creal(vy, vq)), less(times(vx, sort_int::cint(sort_nat::cnat(vq))), times(vy, sort_int::cint(sort_nat::cnat(vp))))));
        result.push_back(data_equation(atermpp::make_vector(vr), less_equal(vr, vr), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), less_equal(creal(vx, vp), creal(vy, vq)), less_equal(times(vx, sort_int::cint(sort_nat::cnat(vq))), times(vy, sort_int::cint(sort_nat::cnat(vp))))));
        result.push_back(data_equation(atermpp::make_vector(vx), int2real(vx), creal(vx, sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vn), nat2real(vn), creal(sort_int::cint(vn), sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vp), pos2real(vp), creal(sort_int::cint(sort_nat::cnat(vp)), sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vx), real2int(creal(vx, sort_pos::c1())), vx));
        result.push_back(data_equation(atermpp::make_vector(vx), real2nat(creal(vx, sort_pos::c1())), sort_int::int2nat(vx)));
        result.push_back(data_equation(atermpp::make_vector(vx), real2pos(creal(vx, sort_pos::c1())), sort_int::int2pos(vx)));
        result.push_back(data_equation(atermpp::make_vector(vr, vs), minimum(vr, vs), if_(less(vr, vs), vr, vs)));
        result.push_back(data_equation(atermpp::make_vector(vr, vs), maximum(vr, vs), if_(less(vr, vs), vs, vr)));
        result.push_back(data_equation(atermpp::make_vector(vr), abs(vr), if_(less(vr, creal(sort_int::cint(sort_nat::c0()), sort_pos::c1())), negate(vr), vr)));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), negate(creal(vx, vp)), creal(negate(vx), vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), succ(creal(vx, vp)), creal(plus(vx, sort_int::cint(sort_nat::cnat(vp))), vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), pred(creal(vx, vp)), creal(minus(vx, sort_int::cint(sort_nat::cnat(vp))), vp)));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), plus(creal(vx, vp), creal(vy, vq)), redfrac(plus(times(vx, sort_int::cint(sort_nat::cnat(vq))), times(vy, sort_int::cint(sort_nat::cnat(vp)))), sort_int::cint(sort_nat::cnat(times(vp, vq))))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), minus(creal(vx, vp), creal(vy, vq)), redfrac(minus(times(vx, sort_int::cint(sort_nat::cnat(vq))), times(vy, sort_int::cint(sort_nat::cnat(vp)))), sort_int::cint(sort_nat::cnat(times(vp, vq))))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), times(creal(vx, vp), creal(vy, vq)), redfrac(times(vx, vy), sort_int::cint(sort_nat::cnat(times(vp, vq))))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx, vy), not_equal_to(vy, sort_int::cint(sort_nat::c0())), divides(creal(vx, vp), creal(vy, vq)), redfrac(times(vx, sort_int::cint(sort_nat::cnat(vq))), times(vy, sort_int::cint(sort_nat::cnat(vp))))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq), divides(vp, vq), redfrac(sort_int::cint(sort_nat::cnat(vp)), sort_int::cint(sort_nat::cnat(vq)))));
        result.push_back(data_equation(atermpp::make_vector(vm, vn), not_equal_to(vm, sort_nat::c0()), divides(vm, vn), redfrac(sort_int::cint(vm), sort_int::cint(vn))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), not_equal_to(vy, sort_int::cint(sort_nat::c0())), divides(vx, vy), redfrac(vx, vy)));
        result.push_back(data_equation(atermpp::make_vector(vn, vp, vx), exp(creal(vx, vp), sort_int::cint(vn)), redfrac(exp(vx, vn), sort_int::cint(sort_nat::cnat(exp(vp, vn))))));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx), not_equal_to(vx, sort_int::cint(sort_nat::c0())), exp(creal(vx, vp), sort_int::cneg(vq)), redfrac(sort_int::cint(sort_nat::cnat(exp(vp, sort_nat::cnat(vq)))), exp(vx, sort_nat::cnat(vq)))));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), floor(creal(vx, vp)), sort_int::div(vx, vp)));
        result.push_back(data_equation(atermpp::make_vector(vr), ceil(vr), negate(floor(negate(vr)))));
        result.push_back(data_equation(atermpp::make_vector(vr), round(vr), floor(plus(vr, creal(sort_int::cint(sort_nat::cnat(sort_pos::c1())), sort_pos::cdub(sort_bool::false_(), sort_pos::c1()))))));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), redfrac(vx, sort_int::cneg(vp)), redfrac(negate(vx), sort_int::cint(sort_nat::cnat(vp)))));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), redfrac(vx, sort_int::cint(sort_nat::cnat(vp))), redfracwhr(vp, sort_int::div(vx, vp), sort_int::mod(vx, vp))));
        result.push_back(data_equation(atermpp::make_vector(vp, vx), redfracwhr(vp, vx, sort_nat::c0()), creal(vx, sort_pos::c1())));
        result.push_back(data_equation(atermpp::make_vector(vp, vq, vx), redfracwhr(vp, vx, sort_nat::cnat(vq)), redfrachlp(redfrac(sort_int::cint(sort_nat::cnat(vp)), sort_int::cint(sort_nat::cnat(vq))), vx)));
        result.push_back(data_equation(atermpp::make_vector(vp, vx, vy), redfrachlp(creal(vx, vp), vy), creal(plus(sort_int::cint(sort_nat::cnat(vp)), times(vy, vx)), sort_int::int2pos(vx))));
        return result;
      }

    }

  }

}
# 38 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h" 1
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_sort.h" 1
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_sort.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h" 1
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h"
namespace mcrl2 {

  namespace data {

    class container_type: public atermpp::aterm_appl
    {
      public:
        container_type()
         : atermpp::aterm_appl(core::detail::constructSortConsType())
        {}

        container_type(atermpp::aterm_appl term)
         : atermpp::aterm_appl(term)
        {
          ((core::detail::check_rule_SortConsType(term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_rule_SortConsType(term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h", 33, __PRETTY_FUNCTION__));
        }
    };



class list_container: public container_type
{
  public:

    list_container()
      : container_type(core::detail::constructSortList())
    {}



    list_container(atermpp::aterm_appl term)
      : container_type(term)
    {
      ((core::detail::check_term_SortList(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortList(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h", 52, __PRETTY_FUNCTION__));
    }
};


class set_container: public container_type
{
  public:

    set_container()
      : container_type(core::detail::constructSortSet())
    {}



    set_container(atermpp::aterm_appl term)
      : container_type(term)
    {
      ((core::detail::check_term_SortSet(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortSet(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h", 70, __PRETTY_FUNCTION__));
    }
};


class bag_container: public container_type
{
  public:

    bag_container()
      : container_type(core::detail::constructSortBag())
    {}



    bag_container(atermpp::aterm_appl term)
      : container_type(term)
    {
      ((core::detail::check_term_SortBag(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortBag(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h", 88, __PRETTY_FUNCTION__));
    }
};


class fset_container: public container_type
{
  public:

    fset_container()
      : container_type(core::detail::constructSortFSet())
    {}



    fset_container(atermpp::aterm_appl term)
      : container_type(term)
    {
      ((core::detail::check_term_SortFSet(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortFSet(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h", 106, __PRETTY_FUNCTION__));
    }
};


class fbag_container: public container_type
{
  public:

    fbag_container()
      : container_type(core::detail::constructSortFBag())
    {}



    fbag_container(atermpp::aterm_appl term)
      : container_type(term)
    {
      ((core::detail::check_term_SortFBag(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortFBag(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_type.h", 124, __PRETTY_FUNCTION__));
    }
};


  }

}
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_sort.h" 2


namespace mcrl2 {

  namespace data {



class container_sort: public sort_expression
{
  public:

    container_sort()
      : sort_expression(core::detail::constructSortCons())
    {}



    container_sort(atermpp::aterm_appl term)
      : sort_expression(term)
    {
      ((core::detail::check_term_SortCons(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortCons(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/container_sort.h", 42, __PRETTY_FUNCTION__));
    }


    container_sort(const container_type& container_name, const sort_expression& element_sort)
      : sort_expression(core::detail::gsMakeSortCons(container_name, element_sort))
    {}

    container_type container_name() const
    {
      return atermpp::arg1(*this);
    }

    sort_expression element_sort() const
    {
      return atermpp::arg2(*this);
    }
};




    typedef atermpp::term_list<container_sort> container_sort_list;



    typedef atermpp::vector<container_sort> container_sort_vector;

  }

}
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h" 2




namespace mcrl2 {

  namespace data {


    namespace sort_list {




      inline
      container_sort list(const sort_expression& s)
      {
        container_sort list(list_container(), s);
        return list;
      }





      inline
      bool is_list(const sort_expression& e)
      {
        if (is_container_sort(e))
        {
          return container_sort(e).container_name() == list_container();
        }
        return false;
      }



      inline
      core::identifier_string const& nil_name()
      {
        static core::identifier_string nil_name = data::detail::initialise_static_expression(nil_name, core::identifier_string("[]"));
        return nil_name;
      }




      inline
      function_symbol nil(const sort_expression& s)
      {
        function_symbol nil(nil_name(), list(s));
        return nil;
      }





      inline
      bool is_nil_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == nil_name();
        }
        return false;
      }



      inline
      core::identifier_string const& cons_name()
      {
        static core::identifier_string cons_name = data::detail::initialise_static_expression(cons_name, core::identifier_string("|>"));
        return cons_name;
      }




      inline
      function_symbol cons_(const sort_expression& s)
      {
        function_symbol cons_(cons_name(), make_function_sort(s, list(s), list(s)));
        return cons_;
      }





      inline
      bool is_cons_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == cons_name();
        }
        return false;
      }






      inline
      application cons_(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return cons_(s)(arg0, arg1);
      }





      inline
      bool is_cons_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_cons_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector list_generate_constructors_code(const sort_expression& s)
      {
        function_symbol_vector result;
        result.push_back(nil(s));
        result.push_back(cons_(s));

        return result;
      }


      inline
      core::identifier_string const& in_name()
      {
        static core::identifier_string in_name = data::detail::initialise_static_expression(in_name, core::identifier_string("in"));
        return in_name;
      }




      inline
      function_symbol in(const sort_expression& s)
      {
        function_symbol in(in_name(), make_function_sort(s, list(s), sort_bool::bool_()));
        return in;
      }





      inline
      bool is_in_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == in_name();
        }
        return false;
      }






      inline
      application in(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return in(s)(arg0, arg1);
      }





      inline
      bool is_in_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_in_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& count_name()
      {
        static core::identifier_string count_name = data::detail::initialise_static_expression(count_name, core::identifier_string("#"));
        return count_name;
      }




      inline
      function_symbol count(const sort_expression& s)
      {
        function_symbol count(count_name(), make_function_sort(list(s), sort_nat::nat()));
        return count;
      }





      inline
      bool is_count_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == count_name();
        }
        return false;
      }





      inline
      application count(const sort_expression& s, const data_expression& arg0)
      {
        return count(s)(arg0);
      }





      inline
      bool is_count_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_count_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& snoc_name()
      {
        static core::identifier_string snoc_name = data::detail::initialise_static_expression(snoc_name, core::identifier_string("<|"));
        return snoc_name;
      }




      inline
      function_symbol snoc(const sort_expression& s)
      {
        function_symbol snoc(snoc_name(), make_function_sort(list(s), s, list(s)));
        return snoc;
      }





      inline
      bool is_snoc_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == snoc_name();
        }
        return false;
      }






      inline
      application snoc(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return snoc(s)(arg0, arg1);
      }





      inline
      bool is_snoc_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_snoc_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& concat_name()
      {
        static core::identifier_string concat_name = data::detail::initialise_static_expression(concat_name, core::identifier_string("++"));
        return concat_name;
      }




      inline
      function_symbol concat(const sort_expression& s)
      {
        function_symbol concat(concat_name(), make_function_sort(list(s), list(s), list(s)));
        return concat;
      }





      inline
      bool is_concat_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == concat_name();
        }
        return false;
      }






      inline
      application concat(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return concat(s)(arg0, arg1);
      }





      inline
      bool is_concat_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_concat_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& element_at_name()
      {
        static core::identifier_string element_at_name = data::detail::initialise_static_expression(element_at_name, core::identifier_string("."));
        return element_at_name;
      }




      inline
      function_symbol element_at(const sort_expression& s)
      {
        function_symbol element_at(element_at_name(), make_function_sort(list(s), sort_nat::nat(), s));
        return element_at;
      }





      inline
      bool is_element_at_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == element_at_name();
        }
        return false;
      }






      inline
      application element_at(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return element_at(s)(arg0, arg1);
      }





      inline
      bool is_element_at_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_element_at_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& head_name()
      {
        static core::identifier_string head_name = data::detail::initialise_static_expression(head_name, core::identifier_string("head"));
        return head_name;
      }




      inline
      function_symbol head(const sort_expression& s)
      {
        function_symbol head(head_name(), make_function_sort(list(s), s));
        return head;
      }





      inline
      bool is_head_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == head_name();
        }
        return false;
      }





      inline
      application head(const sort_expression& s, const data_expression& arg0)
      {
        return head(s)(arg0);
      }





      inline
      bool is_head_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_head_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& tail_name()
      {
        static core::identifier_string tail_name = data::detail::initialise_static_expression(tail_name, core::identifier_string("tail"));
        return tail_name;
      }




      inline
      function_symbol tail(const sort_expression& s)
      {
        function_symbol tail(tail_name(), make_function_sort(list(s), list(s)));
        return tail;
      }





      inline
      bool is_tail_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == tail_name();
        }
        return false;
      }





      inline
      application tail(const sort_expression& s, const data_expression& arg0)
      {
        return tail(s)(arg0);
      }





      inline
      bool is_tail_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_tail_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& rhead_name()
      {
        static core::identifier_string rhead_name = data::detail::initialise_static_expression(rhead_name, core::identifier_string("rhead"));
        return rhead_name;
      }




      inline
      function_symbol rhead(const sort_expression& s)
      {
        function_symbol rhead(rhead_name(), make_function_sort(list(s), s));
        return rhead;
      }





      inline
      bool is_rhead_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == rhead_name();
        }
        return false;
      }





      inline
      application rhead(const sort_expression& s, const data_expression& arg0)
      {
        return rhead(s)(arg0);
      }





      inline
      bool is_rhead_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_rhead_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& rtail_name()
      {
        static core::identifier_string rtail_name = data::detail::initialise_static_expression(rtail_name, core::identifier_string("rtail"));
        return rtail_name;
      }




      inline
      function_symbol rtail(const sort_expression& s)
      {
        function_symbol rtail(rtail_name(), make_function_sort(list(s), list(s)));
        return rtail;
      }





      inline
      bool is_rtail_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == rtail_name();
        }
        return false;
      }





      inline
      application rtail(const sort_expression& s, const data_expression& arg0)
      {
        return rtail(s)(arg0);
      }





      inline
      bool is_rtail_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_rtail_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector list_generate_functions_code(const sort_expression& s)
      {
        function_symbol_vector result;
        result.push_back(in(s));
        result.push_back(count(s));
        result.push_back(snoc(s));
        result.push_back(concat(s));
        result.push_back(element_at(s));
        result.push_back(head(s));
        result.push_back(tail(s));
        result.push_back(rhead(s));
        result.push_back(rtail(s));
        return result;
      }





      inline
      data_expression head(const data_expression& e)
      {
        ((is_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 710, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression right(const data_expression& e)
      {
        ((is_concat_application(e)) ? static_cast<void> (0) : __assert_fail ("is_concat_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 722, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_in_application(e)) ? static_cast<void> (0) : __assert_fail ("is_in_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 734, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_in_application(e)) ? static_cast<void> (0) : __assert_fail ("is_in_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 746, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression list(const data_expression& e)
      {
        ((is_count_application(e) || is_element_at_application(e) || is_head_application(e) || is_tail_application(e) || is_rhead_application(e) || is_rtail_application(e)) ? static_cast<void> (0) : __assert_fail ("is_count_application(e) || is_element_at_application(e) || is_head_application(e) || is_tail_application(e) || is_rhead_application(e) || is_rtail_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 758, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression tail(const data_expression& e)
      {
        ((is_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 770, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression rhead(const data_expression& e)
      {
        ((is_snoc_application(e)) ? static_cast<void> (0) : __assert_fail ("is_snoc_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 782, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression position(const data_expression& e)
      {
        ((is_element_at_application(e)) ? static_cast<void> (0) : __assert_fail ("is_element_at_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 794, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression rtail(const data_expression& e)
      {
        ((is_snoc_application(e)) ? static_cast<void> (0) : __assert_fail ("is_snoc_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 806, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_concat_application(e)) ? static_cast<void> (0) : __assert_fail ("is_concat_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h", 818, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }




      inline
      data_equation_vector list_generate_equations_code(const sort_expression& s)
      {
        variable vd("d",s);
        variable ve("e",s);
        variable vs("s",list(s));
        variable vt("t",list(s));
        variable vp("p",sort_pos::pos());

        data_equation_vector result;
        result.push_back(data_equation(atermpp::make_vector(vd, vs), equal_to(nil(s), cons_(s, vd, vs)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), equal_to(cons_(s, vd, vs), nil(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs, vt), equal_to(cons_(s, vd, vs), cons_(s, ve, vt)), sort_bool::and_(equal_to(vd, ve), equal_to(vs, vt))));
        result.push_back(data_equation(atermpp::make_vector(vd), in(s, vd, nil(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), in(s, vd, cons_(s, ve, vs)), sort_bool::or_(equal_to(vd, ve), in(s, vd, vs))));
        result.push_back(data_equation(variable_list(), count(s, nil(s)), sort_nat::c0()));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), count(s, cons_(s, vd, vs)), sort_nat::cnat(sort_nat::succ(count(s, vs)))));
        result.push_back(data_equation(atermpp::make_vector(vd), snoc(s, nil(s), vd), cons_(s, vd, nil(s))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), snoc(s, cons_(s, vd, vs), ve), cons_(s, vd, snoc(s, vs, ve))));
        result.push_back(data_equation(atermpp::make_vector(vs), concat(s, nil(s), vs), vs));
        result.push_back(data_equation(atermpp::make_vector(vd, vs, vt), concat(s, cons_(s, vd, vs), vt), cons_(s, vd, concat(s, vs, vt))));
        result.push_back(data_equation(atermpp::make_vector(vs), concat(s, vs, nil(s)), vs));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), element_at(s, cons_(s, vd, vs), sort_nat::c0()), vd));
        result.push_back(data_equation(atermpp::make_vector(vd, vp, vs), element_at(s, cons_(s, vd, vs), sort_nat::cnat(vp)), element_at(s, vs, sort_nat::pred(vp))));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), head(s, cons_(s, vd, vs)), vd));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), tail(s, cons_(s, vd, vs)), vs));
        result.push_back(data_equation(atermpp::make_vector(vd), rhead(s, cons_(s, vd, nil(s))), vd));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), rhead(s, cons_(s, vd, cons_(s, ve, vs))), rhead(s, cons_(s, ve, vs))));
        result.push_back(data_equation(atermpp::make_vector(vd), rtail(s, cons_(s, vd, nil(s))), nil(s)));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), rtail(s, cons_(s, vd, cons_(s, ve, vs))), cons_(s, vd, rtail(s, cons_(s, ve, vs)))));
        return result;
      }

    }

  }

}
# 39 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h" 1
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/forall.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/forall.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/abstraction.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/abstraction.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h" 1
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h"
namespace mcrl2 {

  namespace data {

    class binder_type: public atermpp::aterm_appl
    {
      public:
        binder_type()
         : atermpp::aterm_appl(core::detail::constructBindingOperator())
        {}

        binder_type(atermpp::aterm_appl term)
         : atermpp::aterm_appl(term)
        {
          ((core::detail::check_rule_BindingOperator(term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_rule_BindingOperator(term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 33, __PRETTY_FUNCTION__));
        }
    };



class set_or_bag_comprehension_binder: public binder_type
{
  public:

    set_or_bag_comprehension_binder()
      : binder_type(core::detail::constructSetBagComp())
    {}



    set_or_bag_comprehension_binder(atermpp::aterm_appl term)
      : binder_type(term)
    {
      ((core::detail::check_term_SetBagComp(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SetBagComp(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 52, __PRETTY_FUNCTION__));
    }
};


class set_comprehension_binder: public binder_type
{
  public:

    set_comprehension_binder()
      : binder_type(core::detail::constructSetComp())
    {}



    set_comprehension_binder(atermpp::aterm_appl term)
      : binder_type(term)
    {
      ((core::detail::check_term_SetComp(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SetComp(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 70, __PRETTY_FUNCTION__));
    }
};


class bag_comprehension_binder: public binder_type
{
  public:

    bag_comprehension_binder()
      : binder_type(core::detail::constructBagComp())
    {}



    bag_comprehension_binder(atermpp::aterm_appl term)
      : binder_type(term)
    {
      ((core::detail::check_term_BagComp(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_BagComp(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 88, __PRETTY_FUNCTION__));
    }
};


class forall_binder: public binder_type
{
  public:

    forall_binder()
      : binder_type(core::detail::constructForall())
    {}



    forall_binder(atermpp::aterm_appl term)
      : binder_type(term)
    {
      ((core::detail::check_term_Forall(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_Forall(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 106, __PRETTY_FUNCTION__));
    }
};


class exists_binder: public binder_type
{
  public:

    exists_binder()
      : binder_type(core::detail::constructExists())
    {}



    exists_binder(atermpp::aterm_appl term)
      : binder_type(term)
    {
      ((core::detail::check_term_Exists(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_Exists(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 124, __PRETTY_FUNCTION__));
    }
};


class lambda_binder: public binder_type
{
  public:

    lambda_binder()
      : binder_type(core::detail::constructLambda())
    {}



    lambda_binder(atermpp::aterm_appl term)
      : binder_type(term)
    {
      ((core::detail::check_term_Lambda(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_Lambda(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/binder_type.h", 142, __PRETTY_FUNCTION__));
    }
};


  }

}
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/abstraction.h" 2



namespace mcrl2 {

  namespace data {



class abstraction: public data_expression
{
  public:

    abstraction()
      : data_expression(core::detail::constructBinder())
    {}



    abstraction(atermpp::aterm_appl term)
      : data_expression(term)
    {
      ((core::detail::check_term_Binder(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_Binder(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/abstraction.h", 41, __PRETTY_FUNCTION__));
    }


    abstraction(const binder_type& binding_operator, const variable_list& variables, const data_expression& body)
      : data_expression(core::detail::gsMakeBinder(binding_operator, variables, body))
    {}


    template <typename Container>
    abstraction(const binder_type& binding_operator, const Container& variables, const data_expression& body, typename atermpp::detail::enable_if_container<Container, variable>::type* = 0)
      : data_expression(core::detail::gsMakeBinder(binding_operator, atermpp::convert<variable_list>(variables), body))
    {}

    binder_type binding_operator() const
    {
      return atermpp::arg1(*this);
    }

    variable_list variables() const
    {
      return atermpp::list_arg2(*this);
    }

    data_expression body() const
    {
      return atermpp::arg3(*this);
    }
};


   }

}
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/forall.h" 2


namespace mcrl2 {

  namespace data {



    class forall: public abstraction
    {
      public:






        forall(const data_expression& d)
          : abstraction(d)
        {
          ((is_abstraction(d)) ? static_cast<void> (0) : __assert_fail ("is_abstraction(d)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/forall.h", 36, __PRETTY_FUNCTION__));
          ((static_cast<abstraction>(d).binding_operator() == forall_binder()) ? static_cast<void> (0) : __assert_fail ("static_cast<abstraction>(d).binding_operator() == forall_binder()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/forall.h", 37, __PRETTY_FUNCTION__));
        }






        template < typename Container >
        forall(const Container& variables,
               const data_expression& body,
               typename atermpp::detail::enable_if_container< Container, variable >::type* = 0)
          : abstraction(forall_binder(), variables, body)
        {
          ((!variables.empty()) ? static_cast<void> (0) : __assert_fail ("!variables.empty()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/forall.h", 51, __PRETTY_FUNCTION__));
        }

    };

  }

}
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort.h" 1
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/identifier_generator.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/identifier_generator.h"
# 1 "/usr/include/c++/4.1.3/sstream" 1 3
# 42 "/usr/include/c++/4.1.3/sstream" 3
       
# 43 "/usr/include/c++/4.1.3/sstream" 3




namespace std
{
# 61 "/usr/include/c++/4.1.3/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:
# 99 "/usr/include/c++/4.1.3/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 112 "/usr/include/c++/4.1.3/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); }
# 127 "/usr/include/c++/4.1.3/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;
      }
# 151 "/usr/include/c++/4.1.3/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());
# 203 "/usr/include/c++/4.1.3/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());
      }
    };
# 260 "/usr/include/c++/4.1.3/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:
# 298 "/usr/include/c++/4.1.3/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 318 "/usr/include/c++/4.1.3/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()
      { }
# 340 "/usr/include/c++/4.1.3/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); }
    };
# 373 "/usr/include/c++/4.1.3/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:
# 411 "/usr/include/c++/4.1.3/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 431 "/usr/include/c++/4.1.3/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()
      { }
# 453 "/usr/include/c++/4.1.3/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); }
    };
# 486 "/usr/include/c++/4.1.3/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:
# 522 "/usr/include/c++/4.1.3/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 540 "/usr/include/c++/4.1.3/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()
      { }
# 562 "/usr/include/c++/4.1.3/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.1.3/bits/sstream.tcc" 1 3
# 43 "/usr/include/c++/4.1.3/bits/sstream.tcc" 3
       
# 44 "/usr/include/c++/4.1.3/bits/sstream.tcc" 3

# 1 "/usr/include/c++/4.1.3/sstream" 1 3
# 46 "/usr/include/c++/4.1.3/bits/sstream.tcc" 2 3

namespace std
{
  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();



      if (!__testput)
 {






   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
       __size_type(512));
   const __size_type __len = std::min(__opt_len, __max_size);
   __string_type __tmp;
   __tmp.reserve(__len);
   if (this->pbase())
     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
   _M_string.swap(__tmp);
   _M_sync(const_cast<char_type*>(_M_string.data()),
    this->gptr() - this->eback(), this->pptr() - this->pbase());
 }
      return this->sputc(traits_type::to_char_type(__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->gbump((__beg + __newoffi) - this->gptr());
       __ret = pos_type(__newoffi);
     }
   if ((__testout || __testboth)
       && __newoffo >= 0
       && this->egptr() - __beg >= __newoffo)
     {
       this->pbump((__beg + __newoffo) - this->pptr());
       __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->gbump((__beg + __pos) - this->gptr());
       if (__testout)
                this->pbump((__beg + __pos) - this->pptr());
       __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)
 {
   this->setp(__base, __endp);
   this->pbump(__o);



   if (!__testin)
     this->setg(__endg, __endg, __endg);
 }
    }





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


}
# 588 "/usr/include/c++/4.1.3/sstream" 2 3
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/identifier_generator.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/find.h" 1
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/find.h"
# 1 "/usr/include/boost/bind.hpp" 1 3 4
# 22 "/usr/include/boost/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/bind.hpp" 1 3 4
# 25 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/ref.hpp" 1 3 4
# 29 "/usr/include/boost/ref.hpp" 3 4
namespace boost
{

template<class T> class reference_wrapper
{
public:
    typedef T type;







    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}



    operator T& () const { return *t_; }

    T& get() const { return *t_; }

    T* get_pointer() const { return t_; }

private:

    T* t_;
};







template<class T> inline reference_wrapper<T> const ref(T & t)
{
    return reference_wrapper<T>(t);
}

template<class T> inline reference_wrapper<T const> const cref(T const & t)
{
    return reference_wrapper<T const>(t);
}





template<typename T>
class is_reference_wrapper
    : public mpl::false_
{
};

template<typename T>
class unwrap_reference
{
 public:
    typedef T type;
};
# 106 "/usr/include/boost/ref.hpp" 3 4
template<typename T> class is_reference_wrapper< reference_wrapper<T> > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> > { public: typedef T type; };

template<typename T> class is_reference_wrapper< reference_wrapper<T> const > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const > { public: typedef T type; };
template<typename T> class is_reference_wrapper< reference_wrapper<T> volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> volatile > { public: typedef T type; };
template<typename T> class is_reference_wrapper< reference_wrapper<T> const volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const volatile > { public: typedef T type; };
# 176 "/usr/include/boost/ref.hpp" 3 4
template <class T> inline typename unwrap_reference<T>::type&
unwrap_ref(T& t)
{
    return t;
}

template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
{
    return r.get_pointer();
}

}
# 26 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mem_fn.hpp" 1 3 4
# 22 "/usr/include/boost/mem_fn.hpp" 3 4
# 1 "/usr/include/boost/bind/mem_fn.hpp" 1 3 4
# 25 "/usr/include/boost/bind/mem_fn.hpp" 3 4
# 1 "/usr/include/boost/get_pointer.hpp" 1 3 4
# 12 "/usr/include/boost/get_pointer.hpp" 3 4
# 1 "/usr/include/boost/config/no_tr1/memory.hpp" 1 3 4
# 13 "/usr/include/boost/get_pointer.hpp" 2 3 4

namespace boost {



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



template<class T> T * get_pointer(std::auto_ptr<T> const& p)
{
    return p.get();
}


}
# 26 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4


namespace boost
{
# 207 "/usr/include/boost/bind/mem_fn.hpp" 3 4
namespace _mfi
{






# 1 "/usr/include/boost/bind/mem_fn_template.hpp" 1 3 4
# 21 "/usr/include/boost/bind/mem_fn_template.hpp" 3 4
template<class R, class T > class mf0
{
public:

    typedef R result_type;
    typedef T * argument_type;

private:

    typedef R ( T::*F) ();
    F f_;

    template<class U> R call(U & u, T const *) const
    {
        return (u.*f_)();
    }

    template<class U> R call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_)();
    }

public:

    explicit mf0(F f): f_(f) {}

    R operator()(T * p) const
    {
        return (p->*f_)();
    }

    template<class U> R operator()(U & u) const
    {
        return call(u, &u);
    }



    template<class U> R operator()(U const & u) const
    {
        return call(u, &u);
    }



    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
    {
        return call(u, &u);
    }

    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
    {
        return call(u, &u, a1);
    }



    template<class U> R operator()(U const & u, A1 a1) const
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, a1, a2);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, a1, a2, a3);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, a1, a2, a3, a4);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, a1, a2, a3, a4, a5);
    }



    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, 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
    {
        return call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
    }

    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
    {
        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
    }

    bool operator==(cmf8 const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(cmf8 const & rhs) const
    {
        return f_ != rhs.f_;
    }
};
# 216 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
# 258 "/usr/include/boost/bind/mem_fn.hpp" 3 4
}
# 268 "/usr/include/boost/bind/mem_fn.hpp" 3 4
# 1 "/usr/include/boost/bind/mem_fn_cc.hpp" 1 3 4
# 15 "/usr/include/boost/bind/mem_fn_cc.hpp" 3 4
template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
{
    return _mfi::mf0<R, T>(f);
}

template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
{
    return _mfi::cmf0<R, T>(f);
}

template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
{
    return _mfi::mf1<R, T, A1>(f);
}

template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
{
    return _mfi::cmf1<R, T, A1>(f);
}

template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
{
    return _mfi::mf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
{
    return _mfi::cmf2<R, T, A1, A2>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
{
    return _mfi::mf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
{
    return _mfi::cmf3<R, T, A1, A2, A3>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
{
    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
{
    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
{
    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
{
    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
{
    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
{
    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
{
    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
{
    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
{
    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}

template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
{
    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
}
# 269 "/usr/include/boost/bind/mem_fn.hpp" 2 3 4
# 311 "/usr/include/boost/bind/mem_fn.hpp" 3 4
namespace _mfi
{

template<class R, class T> class dm
{
public:

    typedef R const & result_type;
    typedef T const * argument_type;

private:

    typedef R (T::*F);
    F f_;

    template<class U> R const & call(U & u, T const *) const
    {
        return (u.*f_);
    }

    template<class U> R const & call(U & u, void const *) const
    {
        return (get_pointer(u)->*f_);
    }

public:

    explicit dm(F f): f_(f) {}

    R & operator()(T * p) const
    {
        return (p->*f_);
    }

    R const & operator()(T const * p) const
    {
        return (p->*f_);
    }

    template<class U> R const & operator()(U const & u) const
    {
        return call(u, &u);
    }



    R & operator()(T & t) const
    {
        return (t.*f_);
    }

    R const & operator()(T const & t) const
    {
        return (t.*f_);
    }



    bool operator==(dm const & rhs) const
    {
        return f_ == rhs.f_;
    }

    bool operator!=(dm const & rhs) const
    {
        return f_ != rhs.f_;
    }
};

}

template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
{
    return _mfi::dm<R, T>(f);
}

}
# 23 "/usr/include/boost/mem_fn.hpp" 2 3 4
# 27 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/type.hpp" 1 3 4
# 9 "/usr/include/boost/type.hpp" 3 4
namespace boost {



  template <class T>
  struct type {};

}
# 28 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/is_placeholder.hpp" 1 3 4
# 21 "/usr/include/boost/is_placeholder.hpp" 3 4
namespace boost
{

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

}
# 29 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/bind/arg.hpp" 1 3 4
# 25 "/usr/include/boost/bind/arg.hpp" 3 4
namespace boost
{

template< int I > struct arg
{
    arg()
    {
    }

    template< class T > arg( T const & )
    {

        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
    }
};

template< int I > bool operator==( arg<I> const &, arg<I> const & )
{
    return true;
}



template< int I > struct is_placeholder< arg<I> >
{
    enum _vt { value = I };
};

template< int I > struct is_placeholder< arg<I> (*) () >
{
    enum _vt { value = I };
};



}
# 30 "/usr/include/boost/bind/bind.hpp" 2 3 4

# 1 "/usr/include/boost/visit_each.hpp" 1 3 4
# 15 "/usr/include/boost/visit_each.hpp" 3 4
namespace boost {
  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t, long)
  {
    visitor(t);
  }

  template<typename Visitor, typename T>
  inline void visit_each(Visitor& visitor, const T& t)
  {
    visit_each(visitor, t, 0);
  }
}
# 32 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 41 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/storage.hpp" 1 3 4
# 32 "/usr/include/boost/bind/storage.hpp" 3 4
namespace boost
{

namespace _bi
{



template<class A1> struct storage1
{
    explicit storage1( A1 a1 ): a1_( a1 ) {}

    template<class V> void accept(V & v) const
    {
        visit_each(v, a1_, 0);
    }

    A1 a1_;
};



template<int I> struct storage1< boost::arg<I> >
{
    explicit storage1( boost::arg<I> ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};

template<int I> struct storage1< boost::arg<I> (*) () >
{
    explicit storage1( boost::arg<I> (*) () ) {}

    template<class V> void accept(V &) const { }

    static boost::arg<I> a1_() { return boost::arg<I>(); }
};





template<class A1, class A2> struct storage2: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a2_, 0);
    }

    A2 a2_;
};



template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};

template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
{
    typedef storage1<A1> inherited;

    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a2_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a3_, 0);
    }

    A3 a3_;
};



template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};

template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
{
    typedef storage2<A1, A2> inherited;

    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a3_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a4_, 0);
    }

    A4 a4_;
};



template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
{
    typedef storage3<A1, A2, A3> inherited;

    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a4_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a5_, 0);
    }

    A5 a5_;
};



template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
{
    typedef storage4<A1, A2, A3, A4> inherited;

    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a5_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a6_, 0);
    }

    A6 a6_;
};



template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
{
    typedef storage5<A1, A2, A3, A4, A5> inherited;

    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a6_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a7_, 0);
    }

    A7 a7_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
{
    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;

    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a7_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a8_, 0);
    }

    A8 a8_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
{
    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;

    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a8_() { return boost::arg<I>(); }
};





template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
        visit_each(v, a9_, 0);
    }

    A9 a9_;
};



template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
{
    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;

    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}

    template<class V> void accept(V & v) const
    {
        inherited::accept(v);
    }

    static boost::arg<I> a9_() { return boost::arg<I>(); }
};



}

}
# 42 "/usr/include/boost/bind/bind.hpp" 2 3 4






namespace boost
{

template<class T> class weak_ptr;

namespace _bi
{



template<class R, class F> struct result_traits
{
    typedef R type;
};



struct unspecified {};

template<class F> struct result_traits<unspecified, F>
{
    typedef typename F::result_type type;
};

template<class F> struct result_traits< unspecified, reference_wrapper<F> >
{
    typedef typename F::result_type type;
};





template<class T> bool ref_compare( T const & a, T const & b, long )
{
    return a == b;
}

template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
{
    return true;
}

template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
{
    return true;
}

template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
{
    return a.get_pointer() == b.get_pointer();
}



template<class R, class F, class L> class bind_t;

template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
{
    return a.compare( b );
}



template<class T> class value
{
public:

    value(T const & t): t_(t) {}

    T & get() { return t_; }
    T const & get() const { return t_; }

    bool operator==(value const & rhs) const
    {
        return t_ == rhs.t_;
    }

private:

    T t_;
};



template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
{
    return !(a.get() < b.get()) && !(b.get() < a.get());
}



template<class T> class type {};



template<class F> struct unwrapper
{
    static inline F & unwrap( F & f, long )
    {
        return f;
    }

    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
    {
        return rf.get();
    }

    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
    {
        return _mfi::dm<R, T>( pm );
    }
};



class list0
{
public:

    list0() {}

    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }

    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }

    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }

    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }

    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
    {
        return unwrapper<F>::unwrap(f, 0)();
    }

    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
    {
        return unwrapper<F const>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F & f, A &, int)
    {
        unwrapper<F>::unwrap(f, 0)();
    }

    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
    {
        unwrapper<F const>::unwrap(f, 0)();
    }

    template<class V> void accept(V &) const
    {
    }

    bool operator==(list0 const &) const
    {
        return true;
    }
};

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





template<class R, class F, class L> class bind_t
{
public:

    typedef bind_t this_type;

    bind_t(F f, L const & l): f_(f), l_(l) {}


# 1 "/usr/include/boost/bind/bind_template.hpp" 1 3 4
# 15 "/usr/include/boost/bind/bind_template.hpp" 3 4
    typedef typename result_traits<R, F>::type result_type;

    result_type operator()()
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    result_type operator()() const
    {
        list0 a;
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1)
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 & a1) const
    {
        list1<A1 &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1> result_type operator()(A1 const & a1)
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1> result_type operator()(A1 const & a1) const
    {
        list1<A1 const &> a(a1);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
    {
        list2<A1 &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
    {
        list2<A1 const &, A2 &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
    {
        list2<A1 &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }


    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
    {
        list2<A1 const &, A2 const &> a(a1, a2);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
    {
        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
    {
        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
    {
        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
    {
        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
    {
        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
    {
        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
    {
        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
    {
        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
    {
        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
    {
        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
    {
        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
    {
        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
    {
        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }




    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
    {
        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
        return l_(type<result_type>(), f_, a, 0);
    }



    template<class A> result_type eval(A & a)
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class A> result_type eval(A & a) const
    {
        return l_(type<result_type>(), f_, a, 0);
    }

    template<class V> void accept(V & v) const
    {


        using boost::visit_each;


        visit_each(v, f_, 0);
        l_.accept(v);
    }

    bool compare(this_type const & rhs) const
    {
        return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
    }

private:

    F f_;
    L l_;
# 863 "/usr/include/boost/bind/bind.hpp" 2 3 4


};
# 929 "/usr/include/boost/bind/bind.hpp" 3 4
template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
{
    return a.compare(b);
}
# 983 "/usr/include/boost/bind/bind.hpp" 3 4
template< class T, int I > struct add_value_2
{
    typedef boost::arg<I> type;
};

template< class T > struct add_value_2< T, 0 >
{
    typedef _bi::value< T > type;
};

template<class T> struct add_value
{
    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
};



template<class T> struct add_value< value<T> >
{
    typedef _bi::value<T> type;
};

template<class T> struct add_value< reference_wrapper<T> >
{
    typedef reference_wrapper<T> type;
};

template<int I> struct add_value< arg<I> >
{
    typedef boost::arg<I> type;
};

template<int I> struct add_value< arg<I> (*) () >
{
    typedef boost::arg<I> (*type) ();
};

template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
{
    typedef bind_t<R, F, L> type;
};
# 1066 "/usr/include/boost/bind/bind.hpp" 3 4
template<class A1> struct list_av_1
{
    typedef typename add_value<A1>::type B1;
    typedef list1<B1> type;
};

template<class A1, class A2> struct list_av_2
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef list2<B1, B2> type;
};

template<class A1, class A2, class A3> struct list_av_3
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef list3<B1, B2, B3> type;
};

template<class A1, class A2, class A3, class A4> struct list_av_4
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef list4<B1, B2, B3, B4> type;
};

template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef list5<B1, B2, B3, B4, B5> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef list6<B1, B2, B3, B4, B5, B6> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
};

template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
{
    typedef typename add_value<A1>::type B1;
    typedef typename add_value<A2>::type B2;
    typedef typename add_value<A3>::type B3;
    typedef typename add_value<A4>::type B4;
    typedef typename add_value<A5>::type B5;
    typedef typename add_value<A6>::type B6;
    typedef typename add_value<A7>::type B7;
    typedef typename add_value<A8>::type B8;
    typedef typename add_value<A9>::type B9;
    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
};



struct logical_not
{
    template<class V> bool operator()(V const & v) const { return !v; }
};

template<class R, class F, class L>
    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
    operator! (bind_t<R, F, L> const & f)
{
    typedef list1< bind_t<R, F, L> > list_type;
    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
}
# 1189 "/usr/include/boost/bind/bind.hpp" 3 4
struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }

struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }

struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }

struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
# 1229 "/usr/include/boost/bind/bind.hpp" 3 4
template<class V, class T> void visit_each( V & v, value<T> const & t, int )
{
    using boost::visit_each;
    visit_each( v, t.get(), 0 );
}

template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
{
    t.accept( v );
}



}
# 1263 "/usr/include/boost/bind/bind.hpp" 3 4
template< class T > struct is_bind_expression
{
    enum _vt { value = 0 };
};



template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
{
    enum _vt { value = 1 };
};
# 1285 "/usr/include/boost/bind/bind.hpp" 3 4
template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}



template<class R, class F>
    _bi::bind_t<R, F, _bi::list0>
    bind(boost::type<R>, F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class F, class A1>
    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
    bind(boost::type<R>, F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class F, class A1, class A2>
    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R, class F, class A1, class A2, class A3>
    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R, class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}





template<class F>
    _bi::bind_t<_bi::unspecified, F, _bi::list0>
    bind(F f)
{
    typedef _bi::list0 list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
}

template<class F, class A1>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
    bind(F f, A1 a1)
{
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
}

template<class F, class A1, class A2>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
    bind(F f, A1 a1, A2 a2)
{
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
}

template<class F, class A1, class A2, class A3>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(F f, A1 a1, A2 a2, A3 a3)
{
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
}

template<class F, class A1, class A2, class A3, class A4>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class F, class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1538 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/bind_cc.hpp" 1 3 4
# 15 "/usr/include/boost/bind/bind_cc.hpp" 3 4
template<class R>
    _bi::bind_t<R, R ( *) (), _bi::list0>
    bind( R ( *f) ())
{
    typedef R ( *F) ();
    typedef _bi::list0 list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type());
}

template<class R, class B1, class A1>
    _bi::bind_t<R, R ( *) (B1), typename _bi::list_av_1<A1>::type>
    bind( R ( *f) (B1), A1 a1)
{
    typedef R ( *F) (B1);
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
}

template<class R, class B1, class B2, class A1, class A2>
    _bi::bind_t<R, R ( *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
    bind( R ( *f) (B1, B2), A1 a1, A2 a2)
{
    typedef R ( *F) (B1, B2);
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
}

template<class R,
    class B1, class B2, class B3,
    class A1, class A2, class A3>
    _bi::bind_t<R, R ( *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
    bind( R ( *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
{
    typedef R ( *F) (B1, B2, B3);
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
}

template<class R,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind( R ( *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef R ( *F) (B1, B2, B3, B4);
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef R ( *F) (B1, B2, B3, B4, B5);
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6);
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7);
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8);
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1539 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1584 "/usr/include/boost/bind/bind.hpp" 3 4
# 1 "/usr/include/boost/bind/bind_mf_cc.hpp" 1 3 4
# 17 "/usr/include/boost/bind/bind_mf_cc.hpp" 3 4
template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}

template<class R, class T,
    class A1>
    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
}



template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}

template<class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
}



template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1585 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1 "/usr/include/boost/bind/bind_mf2_cc.hpp" 1 3 4
# 18 "/usr/include/boost/bind/bind_mf2_cc.hpp" 3 4
template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
{
    typedef _mfi::mf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}

template<class Rt2, class R, class T,
    class A1>
    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
{
    typedef _mfi::cmf0<R, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
}



template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
{
    typedef _mfi::mf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}

template<class Rt2, class R, class T,
    class B1,
    class A1, class A2>
    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
{
    typedef _mfi::cmf1<R, T, B1> F;
    typedef typename _bi::list_av_2<A1, A2>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
}



template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::mf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}

template<class Rt2, class R, class T,
    class B1, class B2,
    class A1, class A2, class A3>
    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
{
    typedef _mfi::cmf2<R, T, B1, B2> F;
    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::mf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3,
    class A1, class A2, class A3, class A4>
    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
{
    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4,
    class A1, class A2, class A3, class A4, class A5>
    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
{
    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5,
    class A1, class A2, class A3, class A4, class A5, class A6>
    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
{
    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
{
    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
{
    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
}



template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}

template<class Rt2, class R, class T,
    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
{
    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
}
# 1586 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 1645 "/usr/include/boost/bind/bind.hpp" 3 4
namespace _bi
{

template< class Pm, int I > struct add_cref;

template< class M, class T > struct add_cref< M T::*, 0 >
{
    typedef M type;
};

template< class M, class T > struct add_cref< M T::*, 1 >
{
    typedef M const & type;
};

template< class R, class T > struct add_cref< R (T::*) (), 1 >
{
    typedef void type;
};



template< class R, class T > struct add_cref< R (T::*) () const, 1 >
{
    typedef void type;
};



template<class R> struct isref
{
    enum value_type { value = 0 };
};

template<class R> struct isref< R& >
{
    enum value_type { value = 1 };
};

template<class R> struct isref< R* >
{
    enum value_type { value = 1 };
};

template<class Pm, class A1> struct dm_result
{
    typedef typename add_cref< Pm, 1 >::type type;
};

template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
{
    typedef typename bind_t<R, F, L>::result_type result_type;
    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
};

}

template< class A1, class M, class T >

_bi::bind_t<
    typename _bi::dm_result< M T::*, A1 >::type,
    _mfi::dm<M, T>,
    typename _bi::list_av_1<A1>::type
>

bind( M T::*f, A1 a1 )
{
    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
    typedef _mfi::dm<M, T> F;
    typedef typename _bi::list_av_1<A1>::type list_type;
    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
}



}



# 1 "/usr/include/boost/bind/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/bind/placeholders.hpp" 3 4
namespace
{
# 55 "/usr/include/boost/bind/placeholders.hpp" 3 4
boost::arg<1> _1;
boost::arg<2> _2;
boost::arg<3> _3;
boost::arg<4> _4;
boost::arg<5> _5;
boost::arg<6> _6;
boost::arg<7> _7;
boost::arg<8> _8;
boost::arg<9> _9;



}
# 1725 "/usr/include/boost/bind/bind.hpp" 2 3 4
# 23 "/usr/include/boost/bind.hpp" 2 3 4
# 19 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/find.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h" 1
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/algorithm_impl.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/algorithm_impl.h"
# 1 "/usr/include/boost/scoped_array.hpp" 1 3 4
# 14 "/usr/include/boost/scoped_array.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/scoped_array.hpp" 1 3 4
# 14 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 36 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost/assert.hpp" 2 3 4
# 15 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4







namespace boost
{
# 38 "/usr/include/boost/smart_ptr/scoped_array.hpp" 3 4
template<class T> class scoped_array
{
private:

    T * px;

    scoped_array(scoped_array const &);
    scoped_array & operator=(scoped_array const &);

    typedef scoped_array<T> this_type;

    void operator==( scoped_array const& ) const;
    void operator!=( scoped_array const& ) const;

public:

    typedef T element_type;

    explicit scoped_array( T * p = 0 ) : px( p )
    {



    }

    ~scoped_array()
    {



        boost::checked_array_delete( px );
    }

    void reset(T * p = 0)
    {
        ((p == 0 || p != px) ? static_cast<void> (0) : __assert_fail ("p == 0 || p != px", "/usr/include/boost/smart_ptr/scoped_array.hpp", 73, __PRETTY_FUNCTION__));
        this_type(p).swap(*this);
    }

    T & operator[](std::ptrdiff_t i) const
    {
        ((px != 0) ? static_cast<void> (0) : __assert_fail ("px != 0", "/usr/include/boost/smart_ptr/scoped_array.hpp", 79, __PRETTY_FUNCTION__));
        ((i >= 0) ? static_cast<void> (0) : __assert_fail ("i >= 0", "/usr/include/boost/smart_ptr/scoped_array.hpp", 80, __PRETTY_FUNCTION__));
        return px[i];
    }

    T * get() const
    {
        return px;
    }


# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
# 43 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    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;
    }
# 91 "/usr/include/boost/smart_ptr/scoped_array.hpp" 2 3 4

    void swap(scoped_array & b)
    {
        T * tmp = b.px;
        b.px = px;
        px = tmp;
    }
};

template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b)
{
    a.swap(b);
}

}
# 15 "/usr/include/boost/scoped_array.hpp" 2 3 4
# 16 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/algorithm_impl.h" 2





namespace atermpp {

namespace detail {




  template <typename Term, typename Function>
  aterm_list list_apply(term_list<Term> l, const Function f)
  {
    if (l.size() == 0)
      return l;
    aterm_list result;
    for (typename term_list<Term>::iterator i = l.begin(); i != l.end(); ++i)
    {
      result = push_front(result, aterm(f(*i)));
    }
    return reverse(result);
  }
# 63 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/detail/algorithm_impl.h"
  template <typename Term, typename Function>
  aterm_appl appl_apply(term_appl<Term> a, const Function f)
  {
    unsigned int n = a.size();
    if (n > 0)
    {
      bool term_changed = false;
      boost::scoped_array< ATerm > t(new ATerm[n]);
      for (unsigned int i = 0; i < n; ++i)
      {
        t[i] = 0;
      }
      ATprotectArray(t.get(), n);
      for (unsigned int i = 0; i < n; i++)
      {
        t[i] = f(a(i));

        if (t[i] != a(i))
        {
          term_changed = true;
        }
      }
      if (term_changed)
      {
        a = ATmakeApplArray(a.function(), t.get());
      }
      ATunprotectArray(t.get());
    }
    return a;
  }




  template <class Iterator>
  struct iterator_value
  {
    typedef typename std::iterator_traits<Iterator>::value_type type;
  };

  template <class Container>
  struct iterator_value<std::insert_iterator<Container> >
  {
    typedef typename Container::value_type type;
  };

  template <class Container>
  struct iterator_value<std::back_insert_iterator<Container> >
  {
    typedef typename Container::value_type type;
  };

  template <class Container>
  struct iterator_value<std::front_insert_iterator<Container> >
  {
    typedef typename Container::value_type type;
  };



  struct found_term_exception
  {
    aterm_appl t;

    found_term_exception(aterm_appl t_)
      : t(t_)
    {}
  };





  template <typename UnaryFunction>
  UnaryFunction for_each_impl(aterm t, UnaryFunction op)
  {
    if (t.type() == 4L) {
      for (aterm_list::iterator i = aterm_list(t).begin(); i != aterm_list(t).end(); ++i)
      {
        for_each_impl(*i, op);
      }
    }
    else if (t.type() == 1L) {
      if (op(t))
      {
        for (aterm_appl::iterator i = aterm_appl(t).begin(); i != aterm_appl(t).end(); ++i)
        {
          for_each_impl(*i, op);
        }
      }
    }
    return op;
  }





  template <typename MatchPredicate>
  void find_if_impl(aterm t, MatchPredicate match)
  {
    if (t.type() == 1L)
    {
      if (match(aterm_appl(t)))
      {
        throw found_term_exception(aterm_appl(t));
      }
      for (aterm_appl::iterator i = aterm_appl(t).begin(); i != aterm_appl(t).end(); ++i)
      {
        find_if_impl(*i, match);
      }
    }

    if (t.type() == 4L) {
      for (aterm_list::iterator i = aterm_list(t).begin(); i != aterm_list(t).end(); ++i)
      {
        find_if_impl(*i, match);
      }
    }
  }





  template <typename MatchPredicate, typename OutputIterator>
  void find_all_if_impl(aterm t, MatchPredicate op, OutputIterator& destBegin)
  {
    typedef typename iterator_value<OutputIterator>::type value_type;

    if (t.type() == 4L) {
      aterm_list l(t);
      for (aterm_list::iterator i = l.begin(); i != l.end(); ++i)
      {
        find_all_if_impl< MatchPredicate >(*i, op, destBegin);
      }
    }
    else if (t.type() == 1L) {
      aterm_appl a(t);
      if (op(a)) {
          value_type v(a);
        *destBegin++ = a;
      }
      for (aterm_appl::iterator i = a.begin(); i != a.end(); ++i)
      {
        find_all_if_impl< MatchPredicate >(*i, op, destBegin);
      }
    }
    else {
      return;
    }
  }







  template <typename MatchPredicate, typename StopPredicate>
  void partial_find_if_impl(aterm t, MatchPredicate match, StopPredicate stop)
  {
    if (t.type() == 1L)
    {
      if (match(aterm_appl(t)))
      {
        throw found_term_exception(aterm_appl(t));
      }
      if (stop(aterm_appl(t)))
      {
        return;
      }
      for (aterm_appl::iterator i = aterm_appl(t).begin(); i != aterm_appl(t).end(); ++i)
      {
        partial_find_if_impl< MatchPredicate, StopPredicate >(*i, match, stop);
      }
    }

    if (t.type() == 4L)
    {
      for (aterm_list::iterator i = aterm_list(t).begin(); i != aterm_list(t).end(); ++i)
      {
        partial_find_if_impl< MatchPredicate, StopPredicate >(*i, match, stop);
      }
    }
  }






  template <typename MatchPredicate, typename StopPredicate, typename OutputIterator>
  void partial_find_all_if_impl(aterm t, MatchPredicate match, StopPredicate stop, OutputIterator& destBegin)
  {
    if (t.type() == 1L)
    {
      if (match(aterm_appl(t)))
      {
        *destBegin++ = aterm_appl(t);
      }
      if (stop(aterm_appl(t)))
      {
        return;
      }
      for (aterm_appl::iterator i = aterm_appl(t).begin(); i != aterm_appl(t).end(); ++i)
      {
        partial_find_all_if_impl< MatchPredicate, StopPredicate >(*i, match, stop, destBegin);
      }
    }

    if (t.type() == 4L)
    {
      for (aterm_list::iterator i = aterm_list(t).begin(); i != aterm_list(t).end(); ++i)
      {
        partial_find_all_if_impl< MatchPredicate, StopPredicate >(*i, match, stop, destBegin);
      }
    }
  }



  template <typename ReplaceFunction>
  aterm replace_impl(aterm t, ReplaceFunction replace);

  template <typename ReplaceFunction>
  struct replace_helper
  {
    ReplaceFunction m_replace;

    replace_helper(ReplaceFunction replace)
      : m_replace(replace)
    {}




    aterm operator()(aterm t) const
    {
      return replace_impl(t, m_replace);
    }
  };





  template <typename ReplaceFunction>
  aterm replace_impl(aterm t, ReplaceFunction f)
  {
    aterm result = t;
    if (t.type() == 1L)
    {
      aterm_appl a(t);
      aterm_appl fa = f(a);
      result = (a == fa) ? appl_apply(f(a), replace_helper<ReplaceFunction>(f)) : fa;
    }
    else if (t.type() == 4L)
    {
      aterm_list l(t);
      result = list_apply(l, replace_helper<ReplaceFunction>(f));
    }
    return result;
  }

  struct default_replace
  {
    aterm_appl m_src;
    aterm_appl m_dest;

    default_replace(aterm_appl src, aterm_appl dest)
      : m_src(src),
        m_dest(dest)
    { }




    aterm_appl operator()(aterm_appl t) const
    {
      return (t == m_src) ? m_dest : t;
    }
  };



  template <typename ReplaceFunction>
  aterm partial_replace_impl(aterm t, ReplaceFunction replace);

  template <typename ReplaceFunction>
  struct partial_replace_helpsr
  {
    ReplaceFunction m_replace;

    partial_replace_helpsr(ReplaceFunction replace)
      : m_replace(replace)
    {}




    aterm operator()(aterm t) const
    {
      return partial_replace_impl(t, m_replace);
    }
  };





  template <typename ReplaceFunction>
  aterm partial_replace_impl(aterm t, ReplaceFunction f)
  {
    aterm result = t;
    if (t.type() == 1L)
    {
      aterm_appl a(t);
      std::pair<aterm_appl, bool> fa = f(a);
      if (fa.second)
        result = appl_apply(fa.first, partial_replace_helpsr<ReplaceFunction>(f));
      else
        result = fa.first;
    }
    else if (t.type() == 4L)
    {
      aterm_list l(t);
      result = list_apply(l, partial_replace_helpsr<ReplaceFunction>(f));
    }
    return result;
  }



  template <typename ReplaceFunction>
  aterm bottom_up_replace_impl(aterm t, ReplaceFunction bottom_up_replace);

  template <typename ReplaceFunction>
  struct bottom_up_replace_helpsr
  {
    ReplaceFunction m_bottom_up_replace;

    bottom_up_replace_helpsr(ReplaceFunction bottom_up_replace)
      : m_bottom_up_replace(bottom_up_replace)
    {}




    aterm operator()(aterm t) const
    {
      return bottom_up_replace_impl(t, m_bottom_up_replace);
    }
  };





  template <typename ReplaceFunction>
  aterm bottom_up_replace_impl(aterm t, ReplaceFunction f)
  {
    aterm result = t;
    if (t.type() == 1L)
    {
      aterm_appl a(t);
      result = f(appl_apply(a, bottom_up_replace_helpsr<ReplaceFunction>(f)));
    }
    else if (t.type() == 4L)
    {
      aterm_list l(t);
      result = list_apply(l, bottom_up_replace_helpsr<ReplaceFunction>(f));
    }
    return result;
  }

  struct default_bottom_up_replace
  {
    aterm_appl m_src;
    aterm_appl m_dest;

    default_bottom_up_replace(aterm_appl src, aterm_appl dest)
      : m_src(src),
        m_dest(dest)
    { }




    aterm_appl operator()(aterm_appl t) const
    {
      return (t == m_src) ? m_dest : t;
    }
  };

}

}
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h" 2

namespace atermpp
{






  template <typename UnaryFunction, typename Term>
  UnaryFunction for_each(Term t, UnaryFunction op)
  {
    return detail::for_each_impl< typename boost::add_reference< UnaryFunction >::type >(aterm_traits<Term>::term(t), op);
  }





  template <typename Term, typename MatchPredicate>
  aterm_appl find_if(Term t, MatchPredicate match)
  {
    try {
      detail::find_if_impl< typename boost::add_reference< MatchPredicate >::type >(aterm_traits<Term>::term(t), match);
    }
    catch (detail::found_term_exception e) {
      return e.t;
    }
    return aterm_appl();
  }
# 59 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term, typename MatchPredicate, typename StopPredicate>
  aterm_appl partial_find_if(Term t, MatchPredicate match, StopPredicate stop)
  {
    try {
      detail::partial_find_if_impl< typename boost::add_reference< MatchPredicate >::type >(aterm_traits<Term>::term(t), match, stop);
    }
    catch (detail::found_term_exception e) {
      return e.t;
    }
    return aterm_appl();
  }






  template <typename Term, typename MatchPredicate, typename OutputIterator>
  void find_all_if(Term t, MatchPredicate match, OutputIterator destBegin)
  {
    OutputIterator i = destBegin;
    detail::find_all_if_impl< typename boost::add_reference< MatchPredicate >::type >(aterm_traits<Term>::term(t), match, i);
  }
# 91 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term, typename MatchPredicate, typename StopPredicate, typename OutputIterator>
  void partial_find_all_if(Term t, MatchPredicate match, StopPredicate stop, OutputIterator destBegin)
  {
    OutputIterator i = destBegin;
    detail::partial_find_all_if_impl< typename boost::add_reference< MatchPredicate >::type,
                                      typename boost::add_reference< StopPredicate >::type >(aterm_traits<Term>::term(t), match, stop, i);
  }
# 107 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term, typename ReplaceFunction>
  Term replace(Term t, ReplaceFunction r)
  {
    ATerm x = detail::replace_impl< typename boost::add_reference< ReplaceFunction >::type >(aterm_traits<Term>::term(t), r);
    return Term(reinterpret_cast<ATermAppl>(x));
  }
# 121 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term>
  Term replace(Term t, aterm_appl old_value, aterm_appl new_value)
  {
    return replace(t, detail::default_replace(old_value, new_value));
  }
# 136 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term, typename ReplaceFunction>
  Term bottom_up_replace(Term t, ReplaceFunction r)
  {
    ATerm x = detail::bottom_up_replace_impl< typename boost::add_reference< ReplaceFunction >::type >(aterm_traits<Term>::term(t), r);
    return Term(reinterpret_cast<ATermAppl>(x));
  }
# 150 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term>
  Term bottom_up_replace(Term t, aterm_appl old_value, aterm_appl new_value)
  {
    return bottom_up_replace(t, detail::default_replace(old_value, new_value));
  }
# 167 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/algorithm.h"
  template <typename Term, typename ReplaceFunction>
  Term partial_replace(Term t, ReplaceFunction r)
  {
    ATerm x = detail::partial_replace_impl< typename boost::add_reference< ReplaceFunction >::type >(aterm_traits<Term>::term(t), r);
    return Term(reinterpret_cast<ATermAppl>(x));
  }

}
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/find.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/atermpp/include/mcrl2/atermpp/vector.h" 1
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/find.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/identifier_string.h" 1
# 22 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/find.h" 2

namespace mcrl2 {

namespace core {




template <typename Term>
std::set<core::identifier_string> find_identifiers(Term t)
{
  std::set<core::identifier_string> result;
  atermpp::find_all_if(atermpp::aterm_traits<Term>::term(t), core::is_identifier_string, std::inserter(result, result.end()));
  return result;
}


template <typename Term>
std::set<core::identifier_string> find_identifiers(atermpp::vector<Term> v)
{
  std::set<core::identifier_string> result;
  for(typename atermpp::vector<Term>::const_iterator i = v.begin(); i != v.end(); ++i)
  {
    std::set<core::identifier_string> intermediate = find_identifiers(*i);
    for(std::set<core::identifier_string>::const_iterator j = intermediate.begin(); j != intermediate.end(); ++j)
    {
      result.insert(*j);
    }
  }
  return result;
}

}

}
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/identifier_generator.h" 2


namespace mcrl2 {

namespace data {


class number_postfix_generator
{
  protected:

    std::string m_prefix;


    unsigned int m_index;

  public:

    number_postfix_generator()
      : m_prefix("x"), m_index(0)
    {}




    number_postfix_generator(const std::string& prefix, unsigned int index = 0)
     : m_prefix(prefix), m_index(index)
    {}



    core::identifier_string operator()()
    {
      std::ostringstream out;
      out << m_prefix << m_index++;
      return core::identifier_string(out.str());
    }
};







template < typename Generator = number_postfix_generator >
class identifier_generator
{
  public:


    identifier_generator()
    {}


    virtual ~identifier_generator()
    {}


    virtual void clear_context() = 0;



    virtual void add_identifier(core::identifier_string s) = 0;



    virtual void remove_identifier(core::identifier_string s) = 0;



    template <typename Term>
    void add_to_context(Term t, typename atermpp::detail::disable_if_container< Term >::type* = 0)
    {
      std::set<core::identifier_string> s = core::find_identifiers(t);
      for (std::set<core::identifier_string>::iterator i = s.begin(); i != s.end(); ++i)
      {
        add_identifier(*i);
      }
    }



    template < typename Container >
    void add_to_context(Container const& c, typename atermpp::detail::enable_if_container< Container >::type* = 0)
    {
      for (typename Container::const_iterator i = c.begin(); i != c.end(); ++i)
      {
        add_to_context(*i);
      }
    }



    template <typename Container>
    void add_identifiers(const Container& c)
    {
      for (typename Container::const_iterator i = c.begin(); i != c.end(); ++i)
      {
        add_identifier(*i);
      }
    }



    template <typename Term>
    void remove_from_context(Term t)
    {
      std::set<core::identifier_string> s = core::find_identifiers(t);
      for (std::set<core::identifier_string>::iterator i = s.begin(); i != s.end(); ++i)
      {
        remove_identifier(*i);
      }
    }




    virtual bool has_identifier(core::identifier_string s) const = 0;





    virtual core::identifier_string operator()(const std::string& hint)
    {
      core::identifier_string id(hint);

      if (has_identifier(id))
      {
        Generator generator(hint);

        while (has_identifier(id))
        {
          id = core::identifier_string(generator());
        }
      }

      add_to_context(id);
      return id;
    }
};

}

}
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h" 1
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor_argument.h" 1
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor_argument.h"
namespace mcrl2 {

  namespace data {

    namespace detail {



class structured_sort_constructor_argument_base: public atermpp::aterm_appl
{
  public:

    structured_sort_constructor_argument_base()
      : atermpp::aterm_appl(core::detail::constructStructProj())
    {}



    structured_sort_constructor_argument_base(atermpp::aterm_appl term)
      : atermpp::aterm_appl(term)
    {
      ((core::detail::check_term_StructProj(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_StructProj(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor_argument.h", 42, __PRETTY_FUNCTION__));
    }


    structured_sort_constructor_argument_base(const core::identifier_string& name, const sort_expression& sort)
      : atermpp::aterm_appl(core::detail::gsMakeStructProj(name, sort))
    {}


    structured_sort_constructor_argument_base(const std::string& name, const sort_expression& sort)
      : atermpp::aterm_appl(core::detail::gsMakeStructProj(core::identifier_string(name), sort))
    {}

    core::identifier_string name() const
    {
      return atermpp::arg1(*this);
    }

    sort_expression sort() const
    {
      return atermpp::arg2(*this);
    }
};


    }


    inline
    static core::identifier_string const& no_identifier()
    {
      static core::identifier_string dummy;

      return dummy;
    }


    namespace detail {

      inline
      static core::identifier_string make_identifier(std::string const& name)
      {
        return (name.empty()) ? no_identifier() : core::identifier_string(name);
      }

      inline
      static core::identifier_string make_identifier(atermpp::aterm_appl const& a)
      {
        return (a == atermpp::aterm_appl(core::detail::gsMakeNil())) ? no_identifier() : core::identifier_string(a);
      }
    }





    class structured_sort_constructor_argument: public detail::structured_sort_constructor_argument_base
    {
      protected:

        typedef detail::structured_sort_constructor_argument_base super;

        atermpp::aterm_appl make_argument(const sort_expression& sort, const core::identifier_string& name = no_identifier())
        {
          return core::detail::gsMakeStructProj((name == no_identifier()) ?
                   atermpp::aterm_appl(core::detail::gsMakeNil()) : atermpp::aterm_appl(name), sort);
        }

      public:

        structured_sort_constructor_argument()
          : detail::structured_sort_constructor_argument_base()
        {}


        structured_sort_constructor_argument(atermpp::aterm_appl term)
          : detail::structured_sort_constructor_argument_base(term)
        {}






        structured_sort_constructor_argument(const sort_expression& sort, const core::identifier_string& name = no_identifier())
          : detail::structured_sort_constructor_argument_base(make_argument(sort, name))
        {}






        structured_sort_constructor_argument(const sort_expression& sort, const std::string& name)
          : detail::structured_sort_constructor_argument_base(make_argument(sort, detail::make_identifier(name)))
        {}




        template < size_t S >
        structured_sort_constructor_argument(const sort_expression& sort, const char (&name)[S])
          : detail::structured_sort_constructor_argument_base(make_argument(sort, detail::make_identifier(name)))
        {}


        core::identifier_string name() const
        {
          return detail::make_identifier(super::name());
        }

    };


    typedef atermpp::term_list< structured_sort_constructor_argument > structured_sort_constructor_argument_list;

    typedef atermpp::vector< structured_sort_constructor_argument > structured_sort_constructor_argument_vector;

  }

}
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h" 2

namespace mcrl2 {

  namespace data {

    class structured_sort;

    namespace detail {



class structured_sort_constructor_base: public atermpp::aterm_appl
{
  public:

    structured_sort_constructor_base()
      : atermpp::aterm_appl(core::detail::constructStructCons())
    {}



    structured_sort_constructor_base(atermpp::aterm_appl term)
      : atermpp::aterm_appl(term)
    {
      ((core::detail::check_term_StructCons(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_StructCons(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h", 45, __PRETTY_FUNCTION__));
    }


    structured_sort_constructor_base(const core::identifier_string& name, const structured_sort_constructor_argument_list& arguments, core::identifier_string& recogniser)
      : atermpp::aterm_appl(core::detail::gsMakeStructCons(name, arguments, recogniser))
    {}


    template <typename Container>
    structured_sort_constructor_base(const std::string& name, const Container& arguments, const std::string& recogniser, typename atermpp::detail::enable_if_container<Container, structured_sort_constructor_argument>::type* = 0)
      : atermpp::aterm_appl(core::detail::gsMakeStructCons(core::identifier_string(name), atermpp::convert<structured_sort_constructor_argument_list>(arguments), core::identifier_string(recogniser)))
    {}

    core::identifier_string name() const
    {
      return atermpp::arg1(*this);
    }

    structured_sort_constructor_argument_list arguments() const
    {
      return atermpp::list_arg2(*this);
    }

    core::identifier_string recogniser() const
    {
      return atermpp::arg3(*this);
    }
};


    }





    class structured_sort_constructor: public detail::structured_sort_constructor_base
    {
      friend class structured_sort;

      private:

        struct get_argument_sort : public
          std::unary_function< structured_sort_constructor_argument const&, sort_expression > {

          sort_expression operator()(structured_sort_constructor_argument const& s) const {
            return s.sort();
          }
        };

      protected:

        typedef detail::structured_sort_constructor_base super;

        inline
        static atermpp::aterm_appl make_constructor(core::identifier_string const& name,
     atermpp::term_list<structured_sort_constructor_argument> arguments,
                          core::identifier_string const& recogniser)
        {
          ((name != no_identifier()) ? static_cast<void> (0) : __assert_fail ("name != no_identifier()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h", 105, __PRETTY_FUNCTION__));

          return atermpp::aterm_appl(core::detail::gsMakeStructCons(name, arguments,
                  (recogniser == no_identifier()) ? core::detail::gsMakeNil() : static_cast< ATermAppl >(recogniser)));
        }

        inline
        static atermpp::aterm_appl make_constructor(core::identifier_string const& name, core::identifier_string const& recogniser)
        {
          return make_constructor(name, atermpp::term_list< structured_sort_constructor_argument >(), recogniser);
        }

      public:


        typedef atermpp::term_list< structured_sort_constructor_argument >::const_iterator arguments_iterator;

        typedef boost::iterator_range< arguments_iterator > arguments_range;

        typedef boost::iterator_range< arguments_iterator > arguments_const_range;


        typedef atermpp::detail::transform_iterator< get_argument_sort, arguments_iterator > argument_sorts_iterator;

        typedef boost::iterator_range< argument_sorts_iterator > argument_sorts_range;

        typedef boost::iterator_range< argument_sorts_iterator > argument_sorts_const_range;

      public:


        structured_sort_constructor()
          : detail::structured_sort_constructor_base()
        {}



        structured_sort_constructor(atermpp::aterm_appl term)
          : detail::structured_sort_constructor_base(term)
        {}
# 153 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h"
        template < typename Container >
        structured_sort_constructor(const core::identifier_string& name,
                                    const Container& arguments,
                                    const core::identifier_string& recogniser = no_identifier(),
                                    typename atermpp::detail::enable_if_container< Container, structured_sort_constructor_argument >::type* = 0)
          : detail::structured_sort_constructor_base(make_constructor(name, atermpp::convert< atermpp::term_list< structured_sort_constructor_argument > >(arguments), recogniser))
        { }




        template < typename Container >
        structured_sort_constructor(const std::string& name,
                                    const Container& arguments,
                                    const std::string& recogniser,
                                    typename atermpp::detail::enable_if_container< Container, structured_sort_constructor_argument >::type* = 0)
          : detail::structured_sort_constructor_base(make_constructor(detail::make_identifier(name),
               atermpp::convert< atermpp::term_list< structured_sort_constructor_argument > >(arguments), detail::make_identifier(recogniser)))
        { }




        template < typename Container, size_t S, size_t S0 >
        structured_sort_constructor(const char (&name)[S],
                                    const Container& arguments,
                                    const char (&recogniser)[S0],
                                    typename atermpp::detail::enable_if_container< Container, structured_sort_constructor_argument >::type* = 0)
          : detail::structured_sort_constructor_base(make_constructor(detail::make_identifier(name),
               atermpp::convert< atermpp::term_list< structured_sort_constructor_argument > >(arguments), detail::make_identifier(recogniser)))
        { }




        template < typename Container >
        structured_sort_constructor(const std::string& name,
                                    const Container& arguments,
                                    typename atermpp::detail::enable_if_container< Container, structured_sort_constructor_argument >::type* = 0)
          : detail::structured_sort_constructor_base(make_constructor(detail::make_identifier(name),
               atermpp::convert< atermpp::term_list< structured_sort_constructor_argument > >(arguments), no_identifier()))
        { }







        structured_sort_constructor(const core::identifier_string& name, const core::identifier_string& recogniser = no_identifier())
          : detail::structured_sort_constructor_base(make_constructor(name, recogniser))
        { }







        structured_sort_constructor(const std::string& name, const std::string& recogniser = "")
          : detail::structured_sort_constructor_base(make_constructor(detail::make_identifier(name), detail::make_identifier(recogniser)))
        { }




        template < size_t S, size_t S0 >
        structured_sort_constructor(const char (&name)[S], const char (&recogniser)[S0])
          : detail::structured_sort_constructor_base(make_constructor(detail::make_identifier(name), detail::make_identifier(recogniser)))
        { }



        argument_sorts_const_range argument_sorts() const
        {
          return boost::iterator_range< argument_sorts_iterator >(arguments());
        }


        core::identifier_string recogniser() const
        {
          return detail::make_identifier(super::recogniser());
        }
# 247 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort_constructor.h"
        function_symbol constructor_function(const sort_expression& s) const
        {
          argument_sorts_const_range arguments(argument_sorts());

          return function_symbol(name(), (arguments.empty()) ? s : function_sort(arguments, s));
        }




        function_symbol_vector projection_functions(const sort_expression& s) const
        {
          function_symbol_vector result;
          for(arguments_const_range i(arguments()); !i.empty(); i.advance_begin(1))
          {
            if (i.front().name() != no_identifier()) {
              result.push_back(function_symbol(i.front().name(), make_function_sort(s, i.front().sort())));
            }
          }
          return result;
        }





        function_symbol recogniser_function(const sort_expression& s) const
        {
          return function_symbol(recogniser(), make_function_sort(s, sort_bool::bool_()));
        }

    };


    typedef atermpp::term_list< structured_sort_constructor > structured_sort_constructor_list;


    typedef atermpp::vector< structured_sort_constructor > structured_sort_constructor_vector;

  }

}
# 33 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort.h" 2


namespace mcrl2 {

  namespace data {



    namespace sort_fset {
      function_symbol_vector fset_generate_constructors_code(const sort_expression&);
      data_equation_vector fset_generate_equations_code(const sort_expression&);
    }


    namespace sort_fbag {
      function_symbol_vector fbag_generate_constructors_code(const sort_expression&);
      data_equation_vector fbag_generate_equations_code(const sort_expression&);
    }


    namespace detail {



class structured_sort_base: public sort_expression
{
  public:

    structured_sort_base()
      : sort_expression(core::detail::constructSortStruct())
    {}



    structured_sort_base(atermpp::aterm_appl term)
      : sort_expression(term)
    {
      ((core::detail::check_term_SortStruct(m_term)) ? static_cast<void> (0) : __assert_fail ("core::detail::check_term_SortStruct(m_term)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort.h", 70, __PRETTY_FUNCTION__));
    }


    structured_sort_base(const structured_sort_constructor_list& constructors)
      : sort_expression(core::detail::gsMakeSortStruct(constructors))
    {}


    template <typename Container>
    structured_sort_base(const Container& constructors, typename atermpp::detail::enable_if_container<Container, structured_sort_constructor>::type* = 0)
      : sort_expression(core::detail::gsMakeSortStruct(atermpp::convert<structured_sort_constructor_list>(constructors)))
    {}

    structured_sort_constructor_list constructors() const
    {
      return atermpp::list_arg1(*this);
    }
};


    }
# 103 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/structured_sort.h"
    class structured_sort: public detail::structured_sort_base
    {
      friend class data_specification;

      private:

        friend function_symbol_vector sort_fset::fset_generate_constructors_code(const sort_expression&);
        friend data_equation_vector sort_fset::fset_generate_equations_code(const sort_expression&);
        friend function_symbol_vector sort_fbag::fbag_generate_constructors_code(const sort_expression&);
        friend data_equation_vector sort_fbag::fbag_generate_equations_code(const sort_expression&);

        static bool has_recogniser(structured_sort_constructor const& s)
        {
          return !s.recogniser().empty();
        }

        function_symbol_vector constructor_functions(const sort_expression& s) const
        {
          function_symbol_vector result;
          for(constructors_const_range i = struct_constructors(); !i.empty(); i.advance_begin(1))
          {
            result.push_back(i.front().constructor_function(s));
          }
          return result;
        }

        function_symbol_vector projection_functions(const sort_expression& s) const
        {
          function_symbol_vector result;
          for(constructors_const_range i = struct_constructors(); !i.empty(); i.advance_begin(1))
          {
            function_symbol_vector projections(i.front().projection_functions(s));

            for(function_symbol_vector::const_iterator j = projections.begin(); j != projections.end(); ++j)
            {
              result.push_back(*j);
            }
          }
          return result;
        }

        function_symbol_vector recogniser_functions(const sort_expression& s) const
        {
          function_symbol_vector result;
          for(constructors_const_range i = struct_constructors(); !i.empty(); i.advance_begin(1))
          {
            if (i.front().recogniser() != no_identifier()) {
              result.push_back(i.front().recogniser_function(s));
            }
          }
          return result;
        }

        data_equation_vector constructor_equations(const sort_expression& s) const
        {
          data_equation_vector result;

          structured_sort_constructor_vector cl(boost::copy_range< structured_sort_constructor_vector >(struct_constructors()));

          for (structured_sort_constructor_vector::const_iterator i = cl.begin(); i != cl.end(); ++i)
          {
            for (structured_sort_constructor_vector::const_iterator j = cl.begin(); j != cl.end(); ++j)
            {
              data_expression right_equal = (i == j) ? sort_bool::true_() : sort_bool::false_();
              data_expression right_smaller = (i < j) ? sort_bool::true_() : sort_bool::false_();
              data_expression right_smaller_equal = (i <= j) ? sort_bool::true_() : sort_bool::false_();

              if (i->argument_sorts().empty() && j->argument_sorts().empty())
              {
                data_expression operand_left = i->constructor_function(s);
                data_expression operand_right = j->constructor_function(s);

                result.push_back(data_equation(equal_to(operand_left, operand_right), right_equal));
                result.push_back(data_equation(less(operand_left, operand_right), right_smaller));
                result.push_back(data_equation(less_equal(operand_left, operand_right), right_smaller_equal));
              }
              else {
                data_expression operand_left;
                data_expression operand_right;

                number_postfix_generator generator("v");


                atermpp::vector< variable > variables;

                if (i->argument_sorts().empty())
                {
                  operand_left = i->constructor_function(s);
                }
                else
                {
                  for (structured_sort_constructor::arguments_const_range k(i->arguments()); k.begin() != k.end(); k.advance_begin(1))
                  {
                    variables.push_back(variable(generator(), k.front().sort()));
                  }


                  operand_left = application(i->constructor_function(s), variables);
                }

                if (j->argument_sorts().empty())
                {
                  operand_right = j->constructor_function(s);
                }
                else
                {
                  for (structured_sort_constructor::arguments_const_range k(j->arguments()); k.begin() != k.end(); k.advance_begin(1))
                  {
                    variables.push_back(variable(generator(), k.front().sort()));
                  }


                  operand_right = application(j->constructor_function(s),
                             boost::make_iterator_range(boost::next(variables.begin(), boost::distance(i->arguments())), variables.end()));
                }

                if (i == j)
                {
                  variable_vector::const_reverse_iterator k(variables.rbegin() + boost::distance(i->arguments()));
                  variable_vector::const_reverse_iterator l(variables.rbegin());
                  variable_vector::const_reverse_iterator end(variables.rend());

                  right_equal = equal_to(*k, *l);
                  right_smaller = less(*k, *l);
                  right_smaller_equal = less_equal(*k, *l);

                  for (++l, ++k; k != end; ++l, ++k)
                  {



                    right_equal = sort_bool::and_(equal_to(*k, *l), right_equal);





                    right_smaller = sort_bool::or_(less(*k, *l),
                        sort_bool::and_(equal_to(*k, *l), right_smaller));





                    right_smaller_equal = sort_bool::or_(less(*k, *l),
                        sort_bool::and_(equal_to(*k, *l), right_smaller_equal));
                  }
                }

                result.push_back(data_equation(variables,
                  equal_to(operand_left, operand_right), right_equal));
                result.push_back(data_equation(variables,
                  less(operand_left, operand_right), right_smaller));
                result.push_back(data_equation(variables,
                  less_equal(operand_left, operand_right), right_smaller_equal));
              }
            }
          }

          return result;
        }

        data_equation_vector projection_equations(const sort_expression& s) const
        {
          data_equation_vector result;

          for (constructors_const_range i(struct_constructors());
                                         i.begin() != i.end(); i.advance_begin(1))
          {
            if (!i.front().argument_sorts().empty())
            {
              structured_sort_constructor::arguments_const_range arguments(i.front().arguments());

              number_postfix_generator generator("v");

              atermpp::vector< variable > variables;


              for (structured_sort_constructor::arguments_const_range::const_iterator j(arguments.begin()); j != arguments.end(); ++j)
              {
                variables.push_back(variable(generator(), j->sort()));
              }

              atermpp::vector< variable >::const_iterator v = variables.begin();

              for (structured_sort_constructor::arguments_const_range::const_iterator j(arguments.begin()); j != arguments.end(); ++j, ++v)
              {
                if (j->name() != no_identifier()) {
                  application lhs(function_symbol(j->name(), make_function_sort(s, j->sort()))
                        (application(i.front().constructor_function(s), variables)));

                  result.push_back(data_equation(variables, lhs, *v));
                }
              }
            }
          }

          return result;
        }

        data_equation_vector recogniser_equations(const sort_expression& s) const
        {
          data_equation_vector result;

          constructors_const_range cl(struct_constructors());

          for (constructors_const_range::iterator i = cl.begin(); i != cl.end(); ++i)
          {
            for (constructors_const_range::iterator j = cl.begin(); j != cl.end(); ++j)
            {
              if(j->recogniser() != no_identifier())
              {
                data_expression right = (*i == *j) ? sort_bool::true_() : sort_bool::false_();

                if (i->argument_sorts().empty())
                {
                  result.push_back(data_equation(j->recogniser_function(s)(i->constructor_function(s)), right));
                }
                else
                {
                  typedef structured_sort_constructor::arguments_const_range argument_range;

                  number_postfix_generator generator("v");

                  argument_range arguments(i->arguments());


                  variable_vector variables;

                  for (argument_range::const_iterator k(arguments.begin()); k != arguments.end(); ++k)
                  {
                    variables.push_back(variable(generator(), k->sort()));
                  }

                  result.push_back(data_equation(variables, j->recogniser_function(s)(
                    application(i->constructor_function(s), variables)), right));
                }
              }
            }
          }

          return result;
        }

      public:


        typedef boost::iterator_range< structured_sort_constructor_list::iterator > constructors_range;

        typedef boost::iterator_range< structured_sort_constructor_list::const_iterator > constructors_const_range;


        typedef boost::iterator_range< function_symbol_list::iterator > constructor_function_range;

        typedef boost::iterator_range< function_symbol_list::const_iterator > constructor_function_const_range;


        typedef boost::iterator_range< function_symbol_list::iterator > projection_function_range;

        typedef boost::iterator_range< function_symbol_list::const_iterator > projection_function_const_range;


        typedef boost::iterator_range< function_symbol_list::iterator > recogniser_function_range;

        typedef boost::iterator_range< function_symbol_list::const_iterator > recogniser_function_const_range;

      public:


        structured_sort()
          : detail::structured_sort_base()
        {}


        structured_sort(atermpp::aterm_appl term)
          : detail::structured_sort_base(term)
        {}


        structured_sort(const structured_sort_constructor_list& constructors)
          : detail::structured_sort_base(constructors)
        {}


        template <typename Container>
        structured_sort(const Container& constructors, typename atermpp::detail::enable_if_container<Container, structured_sort_constructor>::type* = 0)
          : detail::structured_sort_base(constructors)
        {}



        constructors_const_range struct_constructors() const
        {
          return structured_sort_constructor_list(atermpp::arg1(*this));
        }




        function_symbol_vector constructor_functions() const
        {
          return constructor_functions(*this);
        }



        function_symbol_vector projection_functions() const
        {
          return projection_functions(*this);
        }




        function_symbol_vector recogniser_functions() const
        {
          return recogniser_functions(*this);
        }




        data_equation_vector constructor_equations() const
        {
          return constructor_equations(*this);
        }


        data_equation_vector projection_equations() const
        {
          return projection_equations(*this);
        }




        data_equation_vector recogniser_equations() const
        {
          return recogniser_equations(*this);
        }

    };


    typedef atermpp::term_list< structured_sort > structured_sort_list;

  }

}
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h" 1
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h"
namespace mcrl2 {

  namespace data {


    namespace sort_fset {




      inline
      container_sort fset(const sort_expression& s)
      {
        container_sort fset(fset_container(), s);
        return fset;
      }





      inline
      bool is_fset(const sort_expression& e)
      {
        if (is_container_sort(e))
        {
          return container_sort(e).container_name() == fset_container();
        }
        return false;
      }

      namespace detail {




        inline
        structured_sort fset_struct(const sort_expression& s)
        {
          structured_sort_constructor_vector constructors;
          constructors.push_back(structured_sort_constructor("@fset_empty", "fset_empty"));
          constructors.push_back(structured_sort_constructor("@fset_cons", atermpp::make_vector(structured_sort_constructor_argument(s, "head"), structured_sort_constructor_argument(fset(s), "tail")), "fset_cons"));
          return structured_sort(constructors);
        }

      }



      inline
      core::identifier_string const& fset_empty_name()
      {
        static core::identifier_string fset_empty_name = data::detail::initialise_static_expression(fset_empty_name, core::identifier_string("@fset_empty"));
        return fset_empty_name;
      }




      inline
      function_symbol fset_empty(const sort_expression& s)
      {
        function_symbol fset_empty(fset_empty_name(), fset(s));
        return fset_empty;
      }





      inline
      bool is_fset_empty_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fset_empty_name();
        }
        return false;
      }



      inline
      core::identifier_string const& fset_cons_name()
      {
        static core::identifier_string fset_cons_name = data::detail::initialise_static_expression(fset_cons_name, core::identifier_string("@fset_cons"));
        return fset_cons_name;
      }




      inline
      function_symbol fset_cons(const sort_expression& s)
      {
        function_symbol fset_cons(fset_cons_name(), make_function_sort(s, fset(s), fset(s)));
        return fset_cons;
      }





      inline
      bool is_fset_cons_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fset_cons_name();
        }
        return false;
      }






      inline
      application fset_cons(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return fset_cons(s)(arg0, arg1);
      }





      inline
      bool is_fset_cons_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fset_cons_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector fset_generate_constructors_code(const sort_expression& s)
      {
        function_symbol_vector result;
        function_symbol_vector fset_constructors = detail::fset_struct(s).constructor_functions(fset(s));
        result.insert(result.end(), fset_constructors.begin(), fset_constructors.end());

        return result;
      }


      inline
      core::identifier_string const& fsetinsert_name()
      {
        static core::identifier_string fsetinsert_name = data::detail::initialise_static_expression(fsetinsert_name, core::identifier_string("@fset_insert"));
        return fsetinsert_name;
      }




      inline
      function_symbol fsetinsert(const sort_expression& s)
      {
        function_symbol fsetinsert(fsetinsert_name(), make_function_sort(s, fset(s), fset(s)));
        return fsetinsert;
      }





      inline
      bool is_fsetinsert_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fsetinsert_name();
        }
        return false;
      }






      inline
      application fsetinsert(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return fsetinsert(s)(arg0, arg1);
      }





      inline
      bool is_fsetinsert_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fsetinsert_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fsetcinsert_name()
      {
        static core::identifier_string fsetcinsert_name = data::detail::initialise_static_expression(fsetcinsert_name, core::identifier_string("@fset_cinsert"));
        return fsetcinsert_name;
      }




      inline
      function_symbol fsetcinsert(const sort_expression& s)
      {
        function_symbol fsetcinsert(fsetcinsert_name(), make_function_sort(s, sort_bool::bool_(), fset(s), fset(s)));
        return fsetcinsert;
      }





      inline
      bool is_fsetcinsert_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fsetcinsert_name();
        }
        return false;
      }







      inline
      application fsetcinsert(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return fsetcinsert(s)(arg0, arg1, arg2);
      }





      inline
      bool is_fsetcinsert_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fsetcinsert_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fsetin_name()
      {
        static core::identifier_string fsetin_name = data::detail::initialise_static_expression(fsetin_name, core::identifier_string("@fset_in"));
        return fsetin_name;
      }




      inline
      function_symbol fsetin(const sort_expression& s)
      {
        function_symbol fsetin(fsetin_name(), make_function_sort(s, fset(s), sort_bool::bool_()));
        return fsetin;
      }





      inline
      bool is_fsetin_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fsetin_name();
        }
        return false;
      }






      inline
      application fsetin(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return fsetin(s)(arg0, arg1);
      }





      inline
      bool is_fsetin_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fsetin_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fsetlte_name()
      {
        static core::identifier_string fsetlte_name = data::detail::initialise_static_expression(fsetlte_name, core::identifier_string("@fset_lte"));
        return fsetlte_name;
      }




      inline
      function_symbol fsetlte(const sort_expression& s)
      {
        function_symbol fsetlte(fsetlte_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), fset(s), fset(s), sort_bool::bool_()));
        return fsetlte;
      }





      inline
      bool is_fsetlte_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fsetlte_name();
        }
        return false;
      }







      inline
      application fsetlte(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return fsetlte(s)(arg0, arg1, arg2);
      }





      inline
      bool is_fsetlte_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fsetlte_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fsetunion_name()
      {
        static core::identifier_string fsetunion_name = data::detail::initialise_static_expression(fsetunion_name, core::identifier_string("@fset_union"));
        return fsetunion_name;
      }




      inline
      function_symbol fsetunion(const sort_expression& s)
      {
        function_symbol fsetunion(fsetunion_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_()), fset(s), fset(s), fset(s)));
        return fsetunion;
      }





      inline
      bool is_fsetunion_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fsetunion_name();
        }
        return false;
      }
# 456 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h"
      inline
      application fsetunion(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return fsetunion(s)(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_fsetunion_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fsetunion_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fsetintersection_name()
      {
        static core::identifier_string fsetintersection_name = data::detail::initialise_static_expression(fsetintersection_name, core::identifier_string("@fset_inter"));
        return fsetintersection_name;
      }




      inline
      function_symbol fsetintersection(const sort_expression& s)
      {
        function_symbol fsetintersection(fsetintersection_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_()), fset(s), fset(s), fset(s)));
        return fsetintersection;
      }





      inline
      bool is_fsetintersection_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fsetintersection_name();
        }
        return false;
      }
# 516 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h"
      inline
      application fsetintersection(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return fsetintersection(s)(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_fsetintersection_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fsetintersection_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector fset_generate_functions_code(const sort_expression& s)
      {
        function_symbol_vector result;
        result.push_back(fsetinsert(s));
        result.push_back(fsetcinsert(s));
        result.push_back(fsetin(s));
        result.push_back(fsetlte(s));
        result.push_back(fsetunion(s));
        result.push_back(fsetintersection(s));
        return result;
      }





      inline
      data_expression head(const data_expression& e)
      {
        ((is_fset_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fset_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 559, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression right(const data_expression& e)
      {
        ((is_fsetinsert_application(e) || is_fsetin_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fsetinsert_application(e) || is_fsetin_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 571, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_fsetcinsert_application(e) || is_fsetlte_application(e) || is_fsetunion_application(e) || is_fsetintersection_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fsetcinsert_application(e) || is_fsetlte_application(e) || is_fsetunion_application(e) || is_fsetintersection_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 583, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_fsetcinsert_application(e) || is_fsetlte_application(e) || is_fsetunion_application(e) || is_fsetintersection_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fsetcinsert_application(e) || is_fsetlte_application(e) || is_fsetunion_application(e) || is_fsetintersection_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 595, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg3(const data_expression& e)
      {
        ((is_fsetcinsert_application(e) || is_fsetlte_application(e) || is_fsetunion_application(e) || is_fsetintersection_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fsetcinsert_application(e) || is_fsetlte_application(e) || is_fsetunion_application(e) || is_fsetintersection_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 607, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }






      inline
      data_expression arg4(const data_expression& e)
      {
        ((is_fsetunion_application(e) || is_fsetintersection_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fsetunion_application(e) || is_fsetintersection_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 619, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 3);
      }






      inline
      data_expression tail(const data_expression& e)
      {
        ((is_fset_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fset_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 631, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_fsetinsert_application(e) || is_fsetin_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fsetinsert_application(e) || is_fsetin_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fset.h", 643, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }




      inline
      data_equation_vector fset_generate_equations_code(const sort_expression& s)
      {
        variable vd("d",s);
        variable ve("e",s);
        variable vf("f",make_function_sort(s, sort_bool::bool_()));
        variable vg("g",make_function_sort(s, sort_bool::bool_()));
        variable vs("s",fset(s));
        variable vt("t",fset(s));

        data_equation_vector result;
        data_equation_vector fset_equations = detail::fset_struct(s).constructor_equations(fset(s));
        result.insert(result.end(), fset_equations.begin(), fset_equations.end());
        result.push_back(data_equation(atermpp::make_vector(vd), fsetinsert(s, vd, fset_empty(s)), fset_cons(s, vd, fset_empty(s))));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), fsetinsert(s, vd, fset_cons(s, vd, vs)), fset_cons(s, vd, vs)));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), less(vd, ve), fsetinsert(s, vd, fset_cons(s, ve, vs)), fset_cons(s, vd, fset_cons(s, ve, vs))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), less(ve, vd), fsetinsert(s, vd, fset_cons(s, ve, vs)), fset_cons(s, ve, fsetinsert(s, vd, vs))));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), fsetcinsert(s, vd, sort_bool::false_(), vs), vs));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), fsetcinsert(s, vd, sort_bool::true_(), vs), fsetinsert(s, vd, vs)));
        result.push_back(data_equation(atermpp::make_vector(vd), fsetin(s, vd, fset_empty(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), fsetin(s, vd, fset_cons(s, vd, vs)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), less(vd, ve), fsetin(s, vd, fset_cons(s, ve, vs)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs), less(ve, vd), fsetin(s, vd, fset_cons(s, ve, vs)), fsetin(s, vd, vs)));
        result.push_back(data_equation(atermpp::make_vector(vf), fsetlte(s, vf, fset_empty(s), fset_empty(s)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vd, vf, vs), fsetlte(s, vf, fset_cons(s, vd, vs), fset_empty(s)), sort_bool::and_(vf(vd), fsetlte(s, vf, vs, fset_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vt), fsetlte(s, vf, fset_empty(s), fset_cons(s, ve, vt)), sort_bool::and_(sort_bool::not_(vf(ve)), fsetlte(s, vf, fset_empty(s), vt))));
        result.push_back(data_equation(atermpp::make_vector(vd, vf, vs, vt), fsetlte(s, vf, fset_cons(s, vd, vs), fset_cons(s, vd, vt)), fsetlte(s, vf, vs, vt)));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vf, vs, vt), less(vd, ve), fsetlte(s, vf, fset_cons(s, vd, vs), fset_cons(s, ve, vt)), sort_bool::and_(vf(vd), fsetlte(s, vf, vs, fset_cons(s, ve, vt)))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vf, vs, vt), less(ve, vd), fsetlte(s, vf, fset_cons(s, vd, vs), fset_cons(s, ve, vt)), sort_bool::and_(sort_bool::not_(vf(ve)), fsetlte(s, vf, fset_cons(s, vd, vs), vt))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg), fsetunion(s, vf, vg, fset_empty(s), fset_empty(s)), fset_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vd, vf, vg, vs), fsetunion(s, vf, vg, fset_cons(s, vd, vs), fset_empty(s)), fsetcinsert(s, vd, sort_bool::not_(vg(vd)), fsetunion(s, vf, vg, vs, fset_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg, vt), fsetunion(s, vf, vg, fset_empty(s), fset_cons(s, ve, vt)), fsetcinsert(s, ve, sort_bool::not_(vf(ve)), fsetunion(s, vf, vg, fset_empty(s), vt))));
        result.push_back(data_equation(atermpp::make_vector(vd, vf, vg, vs, vt), fsetunion(s, vf, vg, fset_cons(s, vd, vs), fset_cons(s, vd, vt)), fsetcinsert(s, vd, equal_to(vf(vd), vg(vd)), fsetunion(s, vf, vg, vs, vt))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vf, vg, vs, vt), less(vd, ve), fsetunion(s, vf, vg, fset_cons(s, vd, vs), fset_cons(s, ve, vt)), fsetcinsert(s, vd, sort_bool::not_(vg(vd)), fsetunion(s, vf, vg, vs, fset_cons(s, ve, vt)))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vf, vg, vs, vt), less(ve, vd), fsetunion(s, vf, vg, fset_cons(s, vd, vs), fset_cons(s, ve, vt)), fsetcinsert(s, ve, sort_bool::not_(vf(ve)), fsetunion(s, vf, vg, fset_cons(s, vd, vs), vt))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg), fsetintersection(s, vf, vg, fset_empty(s), fset_empty(s)), fset_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vd, vf, vg, vs), fsetintersection(s, vf, vg, fset_cons(s, vd, vs), fset_empty(s)), fsetcinsert(s, vd, vg(vd), fsetintersection(s, vf, vg, vs, fset_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg, vt), fsetintersection(s, vf, vg, fset_empty(s), fset_cons(s, ve, vt)), fsetcinsert(s, ve, vf(ve), fsetintersection(s, vf, vg, fset_empty(s), vt))));
        result.push_back(data_equation(atermpp::make_vector(vd, vf, vg, vs, vt), fsetintersection(s, vf, vg, fset_cons(s, vd, vs), fset_cons(s, vd, vt)), fsetcinsert(s, vd, equal_to(vf(vd), vg(vd)), fsetintersection(s, vf, vg, vs, vt))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vf, vg, vs, vt), less(vd, ve), fsetintersection(s, vf, vg, fset_cons(s, vd, vs), fset_cons(s, ve, vt)), fsetcinsert(s, vd, vg(vd), fsetintersection(s, vf, vg, vs, fset_cons(s, ve, vt)))));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vf, vg, vs, vt), less(ve, vd), fsetintersection(s, vf, vg, fset_cons(s, vd, vs), fset_cons(s, ve, vt)), fsetcinsert(s, ve, vf(ve), fsetintersection(s, vf, vg, fset_cons(s, vd, vs), vt))));
        result.push_back(data_equation(variable_list(), equal_to(fset_empty(s), fset_empty(s)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vs), equal_to(fset_empty(s), fset_cons(s, ve, vs)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vs), equal_to(fset_cons(s, ve, vs), fset_empty(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs, vt), equal_to(fset_cons(s, ve, vt), fset_cons(s, vd, vs)), sort_bool::and_(equal_to(ve, vd), equal_to(vt, vs))));
        result.push_back(data_equation(variable_list(), less(fset_empty(s), fset_empty(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vs), less(fset_empty(s), fset_cons(s, ve, vs)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vs), less(fset_cons(s, ve, vs), fset_empty(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs, vt), less(fset_cons(s, ve, vt), fset_cons(s, vd, vs)), sort_bool::or_(less(ve, vd), sort_bool::and_(equal_to(ve, vd), less(vt, vs)))));
        result.push_back(data_equation(variable_list(), less_equal(fset_empty(s), fset_empty(s)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vs), less_equal(fset_empty(s), fset_cons(s, ve, vs)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vs), less_equal(fset_cons(s, ve, vs), fset_empty(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(vd, ve, vs, vt), less_equal(fset_cons(s, ve, vt), fset_cons(s, vd, vs)), sort_bool::or_(less(ve, vd), sort_bool::and_(equal_to(ve, vd), less_equal(vt, vs)))));
        return result;
      }

    }

  }

}
# 33 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_set {




      inline
      container_sort set_(const sort_expression& s)
      {
        container_sort set_(set_container(), s);
        return set_;
      }





      inline
      bool is_set(const sort_expression& e)
      {
        if (is_container_sort(e))
        {
          return container_sort(e).container_name() == set_container();
        }
        return false;
      }




      inline
      function_symbol_vector set_generate_constructors_code(const sort_expression& s)
      {
        function_symbol_vector result;
        static_cast< void >(s);
        return result;
      }


      inline
      core::identifier_string const& setconstructor_name()
      {
        static core::identifier_string setconstructor_name = data::detail::initialise_static_expression(setconstructor_name, core::identifier_string("@set"));
        return setconstructor_name;
      }




      inline
      function_symbol setconstructor(const sort_expression& s)
      {
        function_symbol setconstructor(setconstructor_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), sort_fset::fset(s), set_(s)));
        return setconstructor;
      }





      inline
      bool is_setconstructor_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setconstructor_name();
        }
        return false;
      }






      inline
      application setconstructor(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return setconstructor(s)(arg0, arg1);
      }





      inline
      bool is_setconstructor_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setconstructor_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& emptyset_name()
      {
        static core::identifier_string emptyset_name = data::detail::initialise_static_expression(emptyset_name, core::identifier_string("{}"));
        return emptyset_name;
      }




      inline
      function_symbol emptyset(const sort_expression& s)
      {
        function_symbol emptyset(emptyset_name(), set_(s));
        return emptyset;
      }





      inline
      bool is_emptyset_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == emptyset_name();
        }
        return false;
      }



      inline
      core::identifier_string const& setfset_name()
      {
        static core::identifier_string setfset_name = data::detail::initialise_static_expression(setfset_name, core::identifier_string("@setfset"));
        return setfset_name;
      }




      inline
      function_symbol setfset(const sort_expression& s)
      {
        function_symbol setfset(setfset_name(), make_function_sort(sort_fset::fset(s), set_(s)));
        return setfset;
      }





      inline
      bool is_setfset_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setfset_name();
        }
        return false;
      }





      inline
      application setfset(const sort_expression& s, const data_expression& arg0)
      {
        return setfset(s)(arg0);
      }





      inline
      bool is_setfset_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setfset_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& setcomprehension_name()
      {
        static core::identifier_string setcomprehension_name = data::detail::initialise_static_expression(setcomprehension_name, core::identifier_string("@setcomp"));
        return setcomprehension_name;
      }




      inline
      function_symbol setcomprehension(const sort_expression& s)
      {
        function_symbol setcomprehension(setcomprehension_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), set_(s)));
        return setcomprehension;
      }





      inline
      bool is_setcomprehension_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setcomprehension_name();
        }
        return false;
      }





      inline
      application setcomprehension(const sort_expression& s, const data_expression& arg0)
      {
        return setcomprehension(s)(arg0);
      }





      inline
      bool is_setcomprehension_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setcomprehension_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& setin_name()
      {
        static core::identifier_string setin_name = data::detail::initialise_static_expression(setin_name, core::identifier_string("in"));
        return setin_name;
      }




      inline
      function_symbol setin(const sort_expression& s)
      {
        function_symbol setin(setin_name(), make_function_sort(s, set_(s), sort_bool::bool_()));
        return setin;
      }





      inline
      bool is_setin_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setin_name();
        }
        return false;
      }






      inline
      application setin(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return setin(s)(arg0, arg1);
      }





      inline
      bool is_setin_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setin_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& setcomplement_name()
      {
        static core::identifier_string setcomplement_name = data::detail::initialise_static_expression(setcomplement_name, core::identifier_string("!"));
        return setcomplement_name;
      }




      inline
      function_symbol setcomplement(const sort_expression& s)
      {
        function_symbol setcomplement(setcomplement_name(), make_function_sort(set_(s), set_(s)));
        return setcomplement;
      }





      inline
      bool is_setcomplement_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setcomplement_name();
        }
        return false;
      }





      inline
      application setcomplement(const sort_expression& s, const data_expression& arg0)
      {
        return setcomplement(s)(arg0);
      }





      inline
      bool is_setcomplement_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setcomplement_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& setunion_name()
      {
        static core::identifier_string setunion_name = data::detail::initialise_static_expression(setunion_name, core::identifier_string("+"));
        return setunion_name;
      }




      inline
      function_symbol setunion_(const sort_expression& s)
      {
        function_symbol setunion_(setunion_name(), make_function_sort(set_(s), set_(s), set_(s)));
        return setunion_;
      }





      inline
      bool is_setunion_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setunion_name();
        }
        return false;
      }






      inline
      application setunion_(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return setunion_(s)(arg0, arg1);
      }





      inline
      bool is_setunion_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setunion_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& setintersection_name()
      {
        static core::identifier_string setintersection_name = data::detail::initialise_static_expression(setintersection_name, core::identifier_string("*"));
        return setintersection_name;
      }




      inline
      function_symbol setintersection(const sort_expression& s)
      {
        function_symbol setintersection(setintersection_name(), make_function_sort(set_(s), set_(s), set_(s)));
        return setintersection;
      }





      inline
      bool is_setintersection_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setintersection_name();
        }
        return false;
      }






      inline
      application setintersection(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return setintersection(s)(arg0, arg1);
      }





      inline
      bool is_setintersection_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setintersection_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& setdifference_name()
      {
        static core::identifier_string setdifference_name = data::detail::initialise_static_expression(setdifference_name, core::identifier_string("-"));
        return setdifference_name;
      }




      inline
      function_symbol setdifference(const sort_expression& s)
      {
        function_symbol setdifference(setdifference_name(), make_function_sort(set_(s), set_(s), set_(s)));
        return setdifference;
      }





      inline
      bool is_setdifference_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == setdifference_name();
        }
        return false;
      }






      inline
      application setdifference(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return setdifference(s)(arg0, arg1);
      }





      inline
      bool is_setdifference_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_setdifference_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& false_function_name()
      {
        static core::identifier_string false_function_name = data::detail::initialise_static_expression(false_function_name, core::identifier_string("@false_"));
        return false_function_name;
      }




      inline
      function_symbol false_function(const sort_expression& s)
      {
        function_symbol false_function(false_function_name(), make_function_sort(s, sort_bool::bool_()));
        return false_function;
      }





      inline
      bool is_false_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == false_function_name();
        }
        return false;
      }





      inline
      application false_function(const sort_expression& s, const data_expression& arg0)
      {
        return false_function(s)(arg0);
      }





      inline
      bool is_false_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_false_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& true_function_name()
      {
        static core::identifier_string true_function_name = data::detail::initialise_static_expression(true_function_name, core::identifier_string("@true_"));
        return true_function_name;
      }




      inline
      function_symbol true_function(const sort_expression& s)
      {
        function_symbol true_function(true_function_name(), make_function_sort(s, sort_bool::bool_()));
        return true_function;
      }





      inline
      bool is_true_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == true_function_name();
        }
        return false;
      }





      inline
      application true_function(const sort_expression& s, const data_expression& arg0)
      {
        return true_function(s)(arg0);
      }





      inline
      bool is_true_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_true_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& not_function_name()
      {
        static core::identifier_string not_function_name = data::detail::initialise_static_expression(not_function_name, core::identifier_string("@not_"));
        return not_function_name;
      }




      inline
      function_symbol not_function(const sort_expression& s)
      {
        function_symbol not_function(not_function_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_())));
        return not_function;
      }





      inline
      bool is_not_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == not_function_name();
        }
        return false;
      }





      inline
      application not_function(const sort_expression& s, const data_expression& arg0)
      {
        return not_function(s)(arg0);
      }





      inline
      bool is_not_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_not_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& and_function_name()
      {
        static core::identifier_string and_function_name = data::detail::initialise_static_expression(and_function_name, core::identifier_string("@and_"));
        return and_function_name;
      }




      inline
      function_symbol and_function(const sort_expression& s)
      {
        function_symbol and_function(and_function_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_())));
        return and_function;
      }





      inline
      bool is_and_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == and_function_name();
        }
        return false;
      }






      inline
      application and_function(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return and_function(s)(arg0, arg1);
      }





      inline
      bool is_and_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_and_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& or_function_name()
      {
        static core::identifier_string or_function_name = data::detail::initialise_static_expression(or_function_name, core::identifier_string("@or_"));
        return or_function_name;
      }




      inline
      function_symbol or_function(const sort_expression& s)
      {
        function_symbol or_function(or_function_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_bool::bool_())));
        return or_function;
      }





      inline
      bool is_or_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == or_function_name();
        }
        return false;
      }






      inline
      application or_function(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return or_function(s)(arg0, arg1);
      }





      inline
      bool is_or_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_or_function_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector set_generate_functions_code(const sort_expression& s)
      {
        function_symbol_vector result;
        result.push_back(setconstructor(s));
        result.push_back(emptyset(s));
        result.push_back(setfset(s));
        result.push_back(setcomprehension(s));
        result.push_back(setin(s));
        result.push_back(setcomplement(s));
        result.push_back(setunion_(s));
        result.push_back(setintersection(s));
        result.push_back(setdifference(s));
        result.push_back(false_function(s));
        result.push_back(true_function(s));
        result.push_back(not_function(s));
        result.push_back(and_function(s));
        result.push_back(or_function(s));
        return result;
      }





      inline
      data_expression right(const data_expression& e)
      {
        ((is_setconstructor_application(e) || is_setin_application(e) || is_setunion_application(e) || is_setintersection_application(e) || is_setdifference_application(e) || is_and_function_application(e) || is_or_function_application(e)) ? static_cast<void> (0) : __assert_fail ("is_setconstructor_application(e) || is_setin_application(e) || is_setunion_application(e) || is_setintersection_application(e) || is_setdifference_application(e) || is_and_function_application(e) || is_or_function_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h", 887, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_setfset_application(e) || is_setcomprehension_application(e) || is_setcomplement_application(e) || is_false_function_application(e) || is_true_function_application(e) || is_not_function_application(e)) ? static_cast<void> (0) : __assert_fail ("is_setfset_application(e) || is_setcomprehension_application(e) || is_setcomplement_application(e) || is_false_function_application(e) || is_true_function_application(e) || is_not_function_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h", 899, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_setconstructor_application(e) || is_setin_application(e) || is_setunion_application(e) || is_setintersection_application(e) || is_setdifference_application(e) || is_and_function_application(e) || is_or_function_application(e)) ? static_cast<void> (0) : __assert_fail ("is_setconstructor_application(e) || is_setin_application(e) || is_setunion_application(e) || is_setintersection_application(e) || is_setdifference_application(e) || is_and_function_application(e) || is_or_function_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h", 911, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }




      inline
      data_equation_vector set_generate_equations_code(const sort_expression& s)
      {
        variable ve("e",s);
        variable vd("d",s);
        variable vs("s",sort_fset::fset(s));
        variable vt("t",sort_fset::fset(s));
        variable vf("f",make_function_sort(s, sort_bool::bool_()));
        variable vg("g",make_function_sort(s, sort_bool::bool_()));
        variable vx("x",set_(s));
        variable vy("y",set_(s));
        variable vc("c",s);

        data_equation_vector result;
        result.push_back(data_equation(variable_list(), emptyset(s), setconstructor(s, false_function(s), sort_fset::fset_empty(s))));
        result.push_back(data_equation(atermpp::make_vector(vs), setfset(s, vs), setconstructor(s, false_function(s), vs)));
        result.push_back(data_equation(atermpp::make_vector(vf), setcomprehension(s, vf), setconstructor(s, vf, sort_fset::fset_empty(s))));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vs), setin(s, ve, setconstructor(s, vf, vs)), not_equal_to(vf(ve), sort_fset::fsetin(s, ve, vs))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg, vs, vt), equal_to(vf, vg), equal_to(setconstructor(s, vf, vs), setconstructor(s, vg, vt)), equal_to(vs, vt)));
        result.push_back(data_equation(atermpp::make_vector(vf, vg, vs, vt), not_equal_to(vf, vg), equal_to(setconstructor(s, vf, vs), setconstructor(s, vg, vt)), forall(atermpp::make_vector(vc), equal_to(setin(s, vc, setconstructor(s, vf, vs)), setin(s, vc, setconstructor(s, vg, vt))))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), less(vx, vy), sort_bool::and_(less_equal(vx, vy), not_equal_to(vx, vy))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), less_equal(vx, vy), equal_to(setintersection(s, vx, vy), vx)));
        result.push_back(data_equation(atermpp::make_vector(vf, vs), setcomplement(s, setconstructor(s, vf, vs)), setconstructor(s, not_function(s, vf), vs)));
        result.push_back(data_equation(atermpp::make_vector(vf, vg, vs, vt), setunion_(s, setconstructor(s, vf, vs), setconstructor(s, vg, vt)), setconstructor(s, or_function(s, vf, vg), sort_fset::fsetunion(s, vf, vg, vs, vt))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg, vs, vt), setintersection(s, setconstructor(s, vf, vs), setconstructor(s, vg, vt)), setconstructor(s, and_function(s, vf, vg), sort_fset::fsetintersection(s, vf, vg, vs, vt))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), setdifference(s, vx, vy), setintersection(s, vx, setcomplement(s, vy))));
        result.push_back(data_equation(atermpp::make_vector(ve), false_function(s, ve), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(ve), true_function(s, ve), sort_bool::true_()));
        result.push_back(data_equation(variable_list(), equal_to(false_function(s), true_function(s)), sort_bool::false_()));
        result.push_back(data_equation(variable_list(), equal_to(true_function(s), false_function(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vf), not_function(s, vf)(ve), sort_bool::not_(vf(ve))));
        result.push_back(data_equation(variable_list(), not_function(s, false_function(s)), true_function(s)));
        result.push_back(data_equation(variable_list(), not_function(s, true_function(s)), false_function(s)));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg), and_function(s, vf, vg)(ve), sort_bool::and_(vf(ve), vg(ve))));
        result.push_back(data_equation(atermpp::make_vector(vf), and_function(s, vf, vf), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), and_function(s, vf, false_function(s)), false_function(s)));
        result.push_back(data_equation(atermpp::make_vector(vf), and_function(s, false_function(s), vf), false_function(s)));
        result.push_back(data_equation(atermpp::make_vector(vf), and_function(s, vf, true_function(s)), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), and_function(s, true_function(s), vf), vf));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg), or_function(s, vf, vg)(ve), sort_bool::or_(vf(ve), vg(ve))));
        result.push_back(data_equation(atermpp::make_vector(vf), or_function(s, vf, vf), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), or_function(s, vf, false_function(s)), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), or_function(s, false_function(s), vf), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), or_function(s, vf, true_function(s)), true_function(s)));
        result.push_back(data_equation(atermpp::make_vector(vf), or_function(s, true_function(s), vf), true_function(s)));
        return result;
      }

    }

  }

}
# 40 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h" 1
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h" 1
# 35 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h"
namespace mcrl2 {

  namespace data {


    namespace sort_fbag {




      inline
      container_sort fbag(const sort_expression& s)
      {
        container_sort fbag(fbag_container(), s);
        return fbag;
      }





      inline
      bool is_fbag(const sort_expression& e)
      {
        if (is_container_sort(e))
        {
          return container_sort(e).container_name() == fbag_container();
        }
        return false;
      }

      namespace detail {




        inline
        structured_sort fbag_struct(const sort_expression& s)
        {
          structured_sort_constructor_vector constructors;
          constructors.push_back(structured_sort_constructor("@fbag_empty", "fbag_empty"));
          constructors.push_back(structured_sort_constructor("@fbag_cons", atermpp::make_vector(structured_sort_constructor_argument(s, "head"), structured_sort_constructor_argument(sort_pos::pos(), "headcount"), structured_sort_constructor_argument(fbag(s), "tail")), "fbag_cons"));
          return structured_sort(constructors);
        }

      }



      inline
      core::identifier_string const& fbag_empty_name()
      {
        static core::identifier_string fbag_empty_name = data::detail::initialise_static_expression(fbag_empty_name, core::identifier_string("@fbag_empty"));
        return fbag_empty_name;
      }




      inline
      function_symbol fbag_empty(const sort_expression& s)
      {
        function_symbol fbag_empty(fbag_empty_name(), fbag(s));
        return fbag_empty;
      }





      inline
      bool is_fbag_empty_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbag_empty_name();
        }
        return false;
      }



      inline
      core::identifier_string const& fbag_cons_name()
      {
        static core::identifier_string fbag_cons_name = data::detail::initialise_static_expression(fbag_cons_name, core::identifier_string("@fbag_cons"));
        return fbag_cons_name;
      }




      inline
      function_symbol fbag_cons(const sort_expression& s)
      {
        function_symbol fbag_cons(fbag_cons_name(), make_function_sort(s, sort_pos::pos(), fbag(s), fbag(s)));
        return fbag_cons;
      }





      inline
      bool is_fbag_cons_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbag_cons_name();
        }
        return false;
      }







      inline
      application fbag_cons(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return fbag_cons(s)(arg0, arg1, arg2);
      }





      inline
      bool is_fbag_cons_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbag_cons_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector fbag_generate_constructors_code(const sort_expression& s)
      {
        function_symbol_vector result;
        function_symbol_vector fbag_constructors = detail::fbag_struct(s).constructor_functions(fbag(s));
        result.insert(result.end(), fbag_constructors.begin(), fbag_constructors.end());

        return result;
      }


      inline
      core::identifier_string const& fbaginsert_name()
      {
        static core::identifier_string fbaginsert_name = data::detail::initialise_static_expression(fbaginsert_name, core::identifier_string("@fbag_insert"));
        return fbaginsert_name;
      }




      inline
      function_symbol fbaginsert(const sort_expression& s)
      {
        function_symbol fbaginsert(fbaginsert_name(), make_function_sort(s, sort_pos::pos(), fbag(s), fbag(s)));
        return fbaginsert;
      }





      inline
      bool is_fbaginsert_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbaginsert_name();
        }
        return false;
      }







      inline
      application fbaginsert(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return fbaginsert(s)(arg0, arg1, arg2);
      }





      inline
      bool is_fbaginsert_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbaginsert_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbagcinsert_name()
      {
        static core::identifier_string fbagcinsert_name = data::detail::initialise_static_expression(fbagcinsert_name, core::identifier_string("@fbag_cinsert"));
        return fbagcinsert_name;
      }




      inline
      function_symbol fbagcinsert(const sort_expression& s)
      {
        function_symbol fbagcinsert(fbagcinsert_name(), make_function_sort(s, sort_nat::nat(), fbag(s), fbag(s)));
        return fbagcinsert;
      }





      inline
      bool is_fbagcinsert_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbagcinsert_name();
        }
        return false;
      }







      inline
      application fbagcinsert(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return fbagcinsert(s)(arg0, arg1, arg2);
      }





      inline
      bool is_fbagcinsert_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbagcinsert_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbagcount_name()
      {
        static core::identifier_string fbagcount_name = data::detail::initialise_static_expression(fbagcount_name, core::identifier_string("@fbag_count"));
        return fbagcount_name;
      }




      inline
      function_symbol fbagcount(const sort_expression& s)
      {
        function_symbol fbagcount(fbagcount_name(), make_function_sort(s, fbag(s), sort_nat::nat()));
        return fbagcount;
      }





      inline
      bool is_fbagcount_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbagcount_name();
        }
        return false;
      }






      inline
      application fbagcount(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return fbagcount(s)(arg0, arg1);
      }





      inline
      bool is_fbagcount_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbagcount_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbagin_name()
      {
        static core::identifier_string fbagin_name = data::detail::initialise_static_expression(fbagin_name, core::identifier_string("@fbag_in"));
        return fbagin_name;
      }




      inline
      function_symbol fbagin(const sort_expression& s)
      {
        function_symbol fbagin(fbagin_name(), make_function_sort(s, fbag(s), sort_bool::bool_()));
        return fbagin;
      }





      inline
      bool is_fbagin_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbagin_name();
        }
        return false;
      }






      inline
      application fbagin(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return fbagin(s)(arg0, arg1);
      }





      inline
      bool is_fbagin_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbagin_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbaglte_name()
      {
        static core::identifier_string fbaglte_name = data::detail::initialise_static_expression(fbaglte_name, core::identifier_string("@fbag_lte"));
        return fbaglte_name;
      }




      inline
      function_symbol fbaglte(const sort_expression& s)
      {
        function_symbol fbaglte(fbaglte_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), fbag(s), fbag(s), sort_bool::bool_()));
        return fbaglte;
      }





      inline
      bool is_fbaglte_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbaglte_name();
        }
        return false;
      }







      inline
      application fbaglte(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return fbaglte(s)(arg0, arg1, arg2);
      }





      inline
      bool is_fbaglte_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbaglte_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbagjoin_name()
      {
        static core::identifier_string fbagjoin_name = data::detail::initialise_static_expression(fbagjoin_name, core::identifier_string("@fbag_join"));
        return fbagjoin_name;
      }




      inline
      function_symbol fbagjoin(const sort_expression& s)
      {
        function_symbol fbagjoin(fbagjoin_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat()), fbag(s), fbag(s), fbag(s)));
        return fbagjoin;
      }





      inline
      bool is_fbagjoin_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbagjoin_name();
        }
        return false;
      }
# 519 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h"
      inline
      application fbagjoin(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return fbagjoin(s)(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_fbagjoin_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbagjoin_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbagintersect_name()
      {
        static core::identifier_string fbagintersect_name = data::detail::initialise_static_expression(fbagintersect_name, core::identifier_string("@fbag_inter"));
        return fbagintersect_name;
      }




      inline
      function_symbol fbagintersect(const sort_expression& s)
      {
        function_symbol fbagintersect(fbagintersect_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat()), fbag(s), fbag(s), fbag(s)));
        return fbagintersect;
      }





      inline
      bool is_fbagintersect_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbagintersect_name();
        }
        return false;
      }
# 579 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h"
      inline
      application fbagintersect(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return fbagintersect(s)(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_fbagintersect_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbagintersect_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbagdifference_name()
      {
        static core::identifier_string fbagdifference_name = data::detail::initialise_static_expression(fbagdifference_name, core::identifier_string("@fbag_diff"));
        return fbagdifference_name;
      }




      inline
      function_symbol fbagdifference(const sort_expression& s)
      {
        function_symbol fbagdifference(fbagdifference_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat()), fbag(s), fbag(s), fbag(s)));
        return fbagdifference;
      }





      inline
      bool is_fbagdifference_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbagdifference_name();
        }
        return false;
      }
# 639 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h"
      inline
      application fbagdifference(const sort_expression& s, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2, const data_expression& arg3)
      {
        return fbagdifference(s)(arg0, arg1, arg2, arg3);
      }





      inline
      bool is_fbagdifference_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbagdifference_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fbag2fset_name()
      {
        static core::identifier_string fbag2fset_name = data::detail::initialise_static_expression(fbag2fset_name, core::identifier_string("@fbag2fset"));
        return fbag2fset_name;
      }




      inline
      function_symbol fbag2fset(const sort_expression& s)
      {
        function_symbol fbag2fset(fbag2fset_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), fbag(s), sort_fset::fset(s)));
        return fbag2fset;
      }





      inline
      bool is_fbag2fset_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fbag2fset_name();
        }
        return false;
      }






      inline
      application fbag2fset(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return fbag2fset(s)(arg0, arg1);
      }





      inline
      bool is_fbag2fset_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fbag2fset_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& fset2fbag_name()
      {
        static core::identifier_string fset2fbag_name = data::detail::initialise_static_expression(fset2fbag_name, core::identifier_string("@fset2fbag"));
        return fset2fbag_name;
      }




      inline
      function_symbol fset2fbag(const sort_expression& s)
      {
        function_symbol fset2fbag(fset2fbag_name(), make_function_sort(sort_fset::fset(s), fbag(s)));
        return fset2fbag;
      }





      inline
      bool is_fset2fbag_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == fset2fbag_name();
        }
        return false;
      }





      inline
      application fset2fbag(const sort_expression& s, const data_expression& arg0)
      {
        return fset2fbag(s)(arg0);
      }





      inline
      bool is_fset2fbag_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_fset2fbag_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector fbag_generate_functions_code(const sort_expression& s)
      {
        function_symbol_vector result;
        result.push_back(fbaginsert(s));
        result.push_back(fbagcinsert(s));
        result.push_back(fbagcount(s));
        result.push_back(fbagin(s));
        result.push_back(fbaglte(s));
        result.push_back(fbagjoin(s));
        result.push_back(fbagintersect(s));
        result.push_back(fbagdifference(s));
        result.push_back(fbag2fset(s));
        result.push_back(fset2fbag(s));
        return result;
      }





      inline
      data_expression head(const data_expression& e)
      {
        ((is_fbag_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbag_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 801, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression right(const data_expression& e)
      {
        ((is_fbagcount_application(e) || is_fbagin_application(e) || is_fbag2fset_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbagcount_application(e) || is_fbagin_application(e) || is_fbag2fset_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 813, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_fbaginsert_application(e) || is_fbagcinsert_application(e) || is_fbaglte_application(e) || is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbaginsert_application(e) || is_fbagcinsert_application(e) || is_fbaglte_application(e) || is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 825, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_fbaginsert_application(e) || is_fbagcinsert_application(e) || is_fbaglte_application(e) || is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbaginsert_application(e) || is_fbagcinsert_application(e) || is_fbaglte_application(e) || is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 837, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg3(const data_expression& e)
      {
        ((is_fbaginsert_application(e) || is_fbagcinsert_application(e) || is_fbaglte_application(e) || is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbaginsert_application(e) || is_fbagcinsert_application(e) || is_fbaglte_application(e) || is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 849, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }






      inline
      data_expression arg4(const data_expression& e)
      {
        ((is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbagjoin_application(e) || is_fbagintersect_application(e) || is_fbagdifference_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 861, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 3);
      }






      inline
      data_expression tail(const data_expression& e)
      {
        ((is_fbag_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbag_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 873, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_fset2fbag_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fset2fbag_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 885, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression headcount(const data_expression& e)
      {
        ((is_fbag_cons_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbag_cons_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 897, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_fbagcount_application(e) || is_fbagin_application(e) || is_fbag2fset_application(e)) ? static_cast<void> (0) : __assert_fail ("is_fbagcount_application(e) || is_fbagin_application(e) || is_fbag2fset_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/fbag.h", 909, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }




      inline
      data_equation_vector fbag_generate_equations_code(const sort_expression& s)
      {
        variable vd("d",s);
        variable ve("e",s);
        variable vp("p",sort_pos::pos());
        variable vq("q",sort_pos::pos());
        variable vb("b",fbag(s));
        variable vc("c",fbag(s));
        variable vs("s",sort_fset::fset(s));
        variable vf("f",make_function_sort(s, sort_nat::nat()));
        variable vg("g",make_function_sort(s, sort_nat::nat()));

        data_equation_vector result;
        data_equation_vector fbag_equations = detail::fbag_struct(s).constructor_equations(fbag(s));
        result.insert(result.end(), fbag_equations.begin(), fbag_equations.end());
        result.push_back(data_equation(atermpp::make_vector(vd, vp), fbaginsert(s, vd, vp, fbag_empty(s)), fbag_cons(s, vd, vp, fbag_empty(s))));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vp, vq), fbaginsert(s, vd, vp, fbag_cons(s, vd, vq, vb)), fbag_cons(s, vd, sort_nat::plus(vp, vq), vb)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, ve, vp, vq), less(vd, ve), fbaginsert(s, vd, vp, fbag_cons(s, ve, vq, vb)), fbag_cons(s, vd, vp, fbag_cons(s, ve, vq, vb))));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, ve, vp, vq), less(ve, vd), fbaginsert(s, vd, vp, fbag_cons(s, ve, vq, vb)), fbag_cons(s, ve, vq, fbaginsert(s, vd, vp, vb))));
        result.push_back(data_equation(atermpp::make_vector(vb, vd), fbagcinsert(s, vd, sort_nat::c0(), vb), vb));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vp), fbagcinsert(s, vd, sort_nat::cnat(vp), vb), fbaginsert(s, vd, vp, vb)));
        result.push_back(data_equation(atermpp::make_vector(vd), fbagcount(s, vd, fbag_empty(s)), sort_nat::c0()));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vp), fbagcount(s, vd, fbag_cons(s, vd, vp, vb)), sort_nat::cnat(vp)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, ve, vp), less(vd, ve), fbagcount(s, vd, fbag_cons(s, ve, vp, vb)), sort_nat::c0()));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, ve, vp), less(ve, vd), fbagcount(s, vd, fbag_cons(s, ve, vp, vb)), fbagcount(s, vd, vb)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd), fbagin(s, vd, vb), greater(fbagcount(s, vd, vb), sort_nat::c0())));
        result.push_back(data_equation(atermpp::make_vector(vf), fbaglte(s, vf, fbag_empty(s), fbag_empty(s)), sort_bool::true_()));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vf, vp), fbaglte(s, vf, fbag_cons(s, vd, vp, vb), fbag_empty(s)), sort_bool::and_(sort_nat::swap_zero_lte(vf(vd), sort_nat::cnat(vp), sort_nat::c0()), fbaglte(s, vf, vb, fbag_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(vc, ve, vf, vq), fbaglte(s, vf, fbag_empty(s), fbag_cons(s, ve, vq, vc)), sort_bool::and_(sort_nat::swap_zero_lte(vf(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbaglte(s, vf, fbag_empty(s), vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, vf, vp, vq), fbaglte(s, vf, fbag_cons(s, vd, vp, vb), fbag_cons(s, vd, vq, vc)), sort_bool::and_(sort_nat::swap_zero_lte(vf(vd), sort_nat::cnat(vp), sort_nat::cnat(vq)), fbaglte(s, vf, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vp, vq), less(vd, ve), fbaglte(s, vf, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), sort_bool::and_(sort_nat::swap_zero_lte(vf(vd), sort_nat::cnat(vp), sort_nat::c0()), fbaglte(s, vf, vb, fbag_cons(s, ve, vq, vc)))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vp, vq), less(ve, vd), fbaglte(s, vf, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), sort_bool::and_(sort_nat::swap_zero_lte(vf(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbaglte(s, vf, fbag_cons(s, vd, vp, vb), vc))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg), fbagjoin(s, vf, vg, fbag_empty(s), fbag_empty(s)), fbag_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vf, vg, vp), fbagjoin(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_empty(s)), fbagcinsert(s, vd, sort_nat::swap_zero_add(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::c0()), fbagjoin(s, vf, vg, vb, fbag_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(vc, ve, vf, vg, vq), fbagjoin(s, vf, vg, fbag_empty(s), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, ve, sort_nat::swap_zero_add(vf(ve), vg(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbagjoin(s, vf, vg, fbag_empty(s), vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, vf, vg, vp, vq), fbagjoin(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, vd, vq, vc)), fbagcinsert(s, vd, sort_nat::swap_zero_add(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::cnat(vq)), fbagjoin(s, vf, vg, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vg, vp, vq), less(vd, ve), fbagjoin(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, vd, sort_nat::swap_zero_add(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::c0()), fbagjoin(s, vf, vg, vb, fbag_cons(s, ve, vq, vc)))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vg, vp, vq), less(ve, vd), fbagjoin(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, ve, sort_nat::swap_zero_add(vf(ve), vg(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbagjoin(s, vf, vg, fbag_cons(s, vd, vp, vb), vc))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg), fbagintersect(s, vf, vg, fbag_empty(s), fbag_empty(s)), fbag_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vf, vg, vp), fbagintersect(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_empty(s)), fbagcinsert(s, vd, sort_nat::swap_zero_min(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::c0()), fbagintersect(s, vf, vg, vb, fbag_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(vc, ve, vf, vg, vq), fbagintersect(s, vf, vg, fbag_empty(s), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, ve, sort_nat::swap_zero_min(vf(ve), vg(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbagintersect(s, vf, vg, fbag_empty(s), vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, vf, vg, vp, vq), fbagintersect(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, vd, vq, vc)), fbagcinsert(s, vd, sort_nat::swap_zero_min(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::cnat(vq)), fbagintersect(s, vf, vg, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vg, vp, vq), less(vd, ve), fbagintersect(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, vd, sort_nat::swap_zero_min(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::c0()), fbagintersect(s, vf, vg, vb, fbag_cons(s, ve, vq, vc)))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vg, vp, vq), less(ve, vd), fbagintersect(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, ve, sort_nat::swap_zero_min(vf(ve), vg(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbagintersect(s, vf, vg, fbag_cons(s, vd, vp, vb), vc))));
        result.push_back(data_equation(atermpp::make_vector(vf, vg), fbagdifference(s, vf, vg, fbag_empty(s), fbag_empty(s)), fbag_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vf, vg, vp), fbagdifference(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_empty(s)), fbagcinsert(s, vd, sort_nat::swap_zero_monus(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::c0()), fbagdifference(s, vf, vg, vb, fbag_empty(s)))));
        result.push_back(data_equation(atermpp::make_vector(vc, ve, vf, vg, vq), fbagdifference(s, vf, vg, fbag_empty(s), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, ve, sort_nat::swap_zero_monus(vf(ve), vg(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbagdifference(s, vf, vg, fbag_empty(s), vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, vf, vg, vp, vq), fbagdifference(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, vd, vq, vc)), fbagcinsert(s, vd, sort_nat::swap_zero_monus(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::cnat(vq)), fbagdifference(s, vf, vg, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vg, vp, vq), less(vd, ve), fbagdifference(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, vd, sort_nat::swap_zero_monus(vf(vd), vg(vd), sort_nat::cnat(vp), sort_nat::c0()), fbagdifference(s, vf, vg, vb, fbag_cons(s, ve, vq, vc)))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vd, ve, vf, vg, vp, vq), less(ve, vd), fbagdifference(s, vf, vg, fbag_cons(s, vd, vp, vb), fbag_cons(s, ve, vq, vc)), fbagcinsert(s, ve, sort_nat::swap_zero_monus(vf(ve), vg(ve), sort_nat::c0(), sort_nat::cnat(vq)), fbagdifference(s, vf, vg, fbag_cons(s, vd, vp, vb), vc))));
        result.push_back(data_equation(atermpp::make_vector(vf), fbag2fset(s, vf, fbag_empty(s)), sort_fset::fset_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vb, vd, vf, vp), fbag2fset(s, vf, fbag_cons(s, vd, vp, vb)), sort_fset::fsetcinsert(s, vd, equal_to(equal_to(vf(vd), sort_nat::cnat(vp)), greater(vf(vd), sort_nat::c0())), fbag2fset(s, vf, vb))));
        result.push_back(data_equation(variable_list(), fset2fbag(s, sort_fset::fset_empty(s)), fbag_empty(s)));
        result.push_back(data_equation(atermpp::make_vector(vd, vs), fset2fbag(s, sort_fset::fset_cons(s, vd, vs)), fbagcinsert(s, vd, sort_nat::cnat(sort_pos::c1()), fset2fbag(s, vs))));
        return result;
      }

    }

  }

}
# 33 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/set.h" 1
# 35 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h" 2

namespace mcrl2 {

  namespace data {


    namespace sort_bag {




      inline
      container_sort bag(const sort_expression& s)
      {
        container_sort bag(bag_container(), s);
        return bag;
      }





      inline
      bool is_bag(const sort_expression& e)
      {
        if (is_container_sort(e))
        {
          return container_sort(e).container_name() == bag_container();
        }
        return false;
      }




      inline
      function_symbol_vector bag_generate_constructors_code(const sort_expression& s)
      {
        function_symbol_vector result;
        static_cast< void >(s);
        return result;
      }


      inline
      core::identifier_string const& bagconstructor_name()
      {
        static core::identifier_string bagconstructor_name = data::detail::initialise_static_expression(bagconstructor_name, core::identifier_string("@bag"));
        return bagconstructor_name;
      }




      inline
      function_symbol bagconstructor(const sort_expression& s)
      {
        function_symbol bagconstructor(bagconstructor_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), sort_fbag::fbag(s), bag(s)));
        return bagconstructor;
      }





      inline
      bool is_bagconstructor_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagconstructor_name();
        }
        return false;
      }






      inline
      application bagconstructor(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return bagconstructor(s)(arg0, arg1);
      }





      inline
      bool is_bagconstructor_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagconstructor_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& emptybag_name()
      {
        static core::identifier_string emptybag_name = data::detail::initialise_static_expression(emptybag_name, core::identifier_string("{}"));
        return emptybag_name;
      }




      inline
      function_symbol emptybag(const sort_expression& s)
      {
        function_symbol emptybag(emptybag_name(), bag(s));
        return emptybag;
      }





      inline
      bool is_emptybag_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == emptybag_name();
        }
        return false;
      }



      inline
      core::identifier_string const& bagfbag_name()
      {
        static core::identifier_string bagfbag_name = data::detail::initialise_static_expression(bagfbag_name, core::identifier_string("@bagfbag"));
        return bagfbag_name;
      }




      inline
      function_symbol bagfbag(const sort_expression& s)
      {
        function_symbol bagfbag(bagfbag_name(), make_function_sort(sort_fbag::fbag(s), bag(s)));
        return bagfbag;
      }





      inline
      bool is_bagfbag_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagfbag_name();
        }
        return false;
      }





      inline
      application bagfbag(const sort_expression& s, const data_expression& arg0)
      {
        return bagfbag(s)(arg0);
      }





      inline
      bool is_bagfbag_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagfbag_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bagcomprehension_name()
      {
        static core::identifier_string bagcomprehension_name = data::detail::initialise_static_expression(bagcomprehension_name, core::identifier_string("@bagcomp"));
        return bagcomprehension_name;
      }




      inline
      function_symbol bagcomprehension(const sort_expression& s)
      {
        function_symbol bagcomprehension(bagcomprehension_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), bag(s)));
        return bagcomprehension;
      }





      inline
      bool is_bagcomprehension_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagcomprehension_name();
        }
        return false;
      }





      inline
      application bagcomprehension(const sort_expression& s, const data_expression& arg0)
      {
        return bagcomprehension(s)(arg0);
      }





      inline
      bool is_bagcomprehension_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagcomprehension_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bagcount_name()
      {
        static core::identifier_string bagcount_name = data::detail::initialise_static_expression(bagcount_name, core::identifier_string("count"));
        return bagcount_name;
      }




      inline
      function_symbol bagcount(const sort_expression& s)
      {
        function_symbol bagcount(bagcount_name(), make_function_sort(s, bag(s), sort_nat::nat()));
        return bagcount;
      }





      inline
      bool is_bagcount_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagcount_name();
        }
        return false;
      }






      inline
      application bagcount(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return bagcount(s)(arg0, arg1);
      }





      inline
      bool is_bagcount_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagcount_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bagin_name()
      {
        static core::identifier_string bagin_name = data::detail::initialise_static_expression(bagin_name, core::identifier_string("in"));
        return bagin_name;
      }




      inline
      function_symbol bagin(const sort_expression& s)
      {
        function_symbol bagin(bagin_name(), make_function_sort(s, bag(s), sort_bool::bool_()));
        return bagin;
      }





      inline
      bool is_bagin_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagin_name();
        }
        return false;
      }






      inline
      application bagin(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return bagin(s)(arg0, arg1);
      }





      inline
      bool is_bagin_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagin_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bagjoin_name()
      {
        static core::identifier_string bagjoin_name = data::detail::initialise_static_expression(bagjoin_name, core::identifier_string("+"));
        return bagjoin_name;
      }




      inline
      function_symbol bagjoin(const sort_expression& s)
      {
        function_symbol bagjoin(bagjoin_name(), make_function_sort(bag(s), bag(s), bag(s)));
        return bagjoin;
      }





      inline
      bool is_bagjoin_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagjoin_name();
        }
        return false;
      }






      inline
      application bagjoin(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return bagjoin(s)(arg0, arg1);
      }





      inline
      bool is_bagjoin_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagjoin_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bagintersect_name()
      {
        static core::identifier_string bagintersect_name = data::detail::initialise_static_expression(bagintersect_name, core::identifier_string("*"));
        return bagintersect_name;
      }




      inline
      function_symbol bagintersect(const sort_expression& s)
      {
        function_symbol bagintersect(bagintersect_name(), make_function_sort(bag(s), bag(s), bag(s)));
        return bagintersect;
      }





      inline
      bool is_bagintersect_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagintersect_name();
        }
        return false;
      }






      inline
      application bagintersect(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return bagintersect(s)(arg0, arg1);
      }





      inline
      bool is_bagintersect_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagintersect_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bagdifference_name()
      {
        static core::identifier_string bagdifference_name = data::detail::initialise_static_expression(bagdifference_name, core::identifier_string("-"));
        return bagdifference_name;
      }




      inline
      function_symbol bagdifference(const sort_expression& s)
      {
        function_symbol bagdifference(bagdifference_name(), make_function_sort(bag(s), bag(s), bag(s)));
        return bagdifference;
      }





      inline
      bool is_bagdifference_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bagdifference_name();
        }
        return false;
      }






      inline
      application bagdifference(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return bagdifference(s)(arg0, arg1);
      }





      inline
      bool is_bagdifference_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bagdifference_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bag2set_name()
      {
        static core::identifier_string bag2set_name = data::detail::initialise_static_expression(bag2set_name, core::identifier_string("Bag2Set"));
        return bag2set_name;
      }




      inline
      function_symbol bag2set(const sort_expression& s)
      {
        function_symbol bag2set(bag2set_name(), make_function_sort(bag(s), sort_set::set_(s)));
        return bag2set;
      }





      inline
      bool is_bag2set_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bag2set_name();
        }
        return false;
      }





      inline
      application bag2set(const sort_expression& s, const data_expression& arg0)
      {
        return bag2set(s)(arg0);
      }





      inline
      bool is_bag2set_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bag2set_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& set2bag_name()
      {
        static core::identifier_string set2bag_name = data::detail::initialise_static_expression(set2bag_name, core::identifier_string("Set2Bag"));
        return set2bag_name;
      }




      inline
      function_symbol set2bag(const sort_expression& s)
      {
        function_symbol set2bag(set2bag_name(), make_function_sort(sort_set::set_(s), bag(s)));
        return set2bag;
      }





      inline
      bool is_set2bag_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == set2bag_name();
        }
        return false;
      }





      inline
      application set2bag(const sort_expression& s, const data_expression& arg0)
      {
        return set2bag(s)(arg0);
      }





      inline
      bool is_set2bag_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_set2bag_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& zero_function_name()
      {
        static core::identifier_string zero_function_name = data::detail::initialise_static_expression(zero_function_name, core::identifier_string("@zero_"));
        return zero_function_name;
      }




      inline
      function_symbol zero_function(const sort_expression& s)
      {
        function_symbol zero_function(zero_function_name(), make_function_sort(s, sort_nat::nat()));
        return zero_function;
      }





      inline
      bool is_zero_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == zero_function_name();
        }
        return false;
      }





      inline
      application zero_function(const sort_expression& s, const data_expression& arg0)
      {
        return zero_function(s)(arg0);
      }





      inline
      bool is_zero_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_zero_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& one_function_name()
      {
        static core::identifier_string one_function_name = data::detail::initialise_static_expression(one_function_name, core::identifier_string("@one_"));
        return one_function_name;
      }




      inline
      function_symbol one_function(const sort_expression& s)
      {
        function_symbol one_function(one_function_name(), make_function_sort(s, sort_nat::nat()));
        return one_function;
      }





      inline
      bool is_one_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == one_function_name();
        }
        return false;
      }





      inline
      application one_function(const sort_expression& s, const data_expression& arg0)
      {
        return one_function(s)(arg0);
      }





      inline
      bool is_one_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_one_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& add_function_name()
      {
        static core::identifier_string add_function_name = data::detail::initialise_static_expression(add_function_name, core::identifier_string("@add_"));
        return add_function_name;
      }




      inline
      function_symbol add_function(const sort_expression& s)
      {
        function_symbol add_function(add_function_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat())));
        return add_function;
      }





      inline
      bool is_add_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == add_function_name();
        }
        return false;
      }






      inline
      application add_function(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return add_function(s)(arg0, arg1);
      }





      inline
      bool is_add_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_add_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& min_function_name()
      {
        static core::identifier_string min_function_name = data::detail::initialise_static_expression(min_function_name, core::identifier_string("@min_"));
        return min_function_name;
      }




      inline
      function_symbol min_function(const sort_expression& s)
      {
        function_symbol min_function(min_function_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat())));
        return min_function;
      }





      inline
      bool is_min_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == min_function_name();
        }
        return false;
      }






      inline
      application min_function(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return min_function(s)(arg0, arg1);
      }





      inline
      bool is_min_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_min_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& monus_function_name()
      {
        static core::identifier_string monus_function_name = data::detail::initialise_static_expression(monus_function_name, core::identifier_string("@monus_"));
        return monus_function_name;
      }




      inline
      function_symbol monus_function(const sort_expression& s)
      {
        function_symbol monus_function(monus_function_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_nat::nat())));
        return monus_function;
      }





      inline
      bool is_monus_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == monus_function_name();
        }
        return false;
      }






      inline
      application monus_function(const sort_expression& s, const data_expression& arg0, const data_expression& arg1)
      {
        return monus_function(s)(arg0, arg1);
      }





      inline
      bool is_monus_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_monus_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& nat2bool_function_name()
      {
        static core::identifier_string nat2bool_function_name = data::detail::initialise_static_expression(nat2bool_function_name, core::identifier_string("@Nat2Bool_"));
        return nat2bool_function_name;
      }




      inline
      function_symbol nat2bool_function(const sort_expression& s)
      {
        function_symbol nat2bool_function(nat2bool_function_name(), make_function_sort(make_function_sort(s, sort_nat::nat()), make_function_sort(s, sort_bool::bool_())));
        return nat2bool_function;
      }





      inline
      bool is_nat2bool_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == nat2bool_function_name();
        }
        return false;
      }





      inline
      application nat2bool_function(const sort_expression& s, const data_expression& arg0)
      {
        return nat2bool_function(s)(arg0);
      }





      inline
      bool is_nat2bool_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_nat2bool_function_function_symbol(application(e).head());
        }
        return false;
      }



      inline
      core::identifier_string const& bool2nat_function_name()
      {
        static core::identifier_string bool2nat_function_name = data::detail::initialise_static_expression(bool2nat_function_name, core::identifier_string("@Bool2Nat_"));
        return bool2nat_function_name;
      }




      inline
      function_symbol bool2nat_function(const sort_expression& s)
      {
        function_symbol bool2nat_function(bool2nat_function_name(), make_function_sort(make_function_sort(s, sort_bool::bool_()), make_function_sort(s, sort_nat::nat())));
        return bool2nat_function;
      }





      inline
      bool is_bool2nat_function_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bool2nat_function_name();
        }
        return false;
      }





      inline
      application bool2nat_function(const sort_expression& s, const data_expression& arg0)
      {
        return bool2nat_function(s)(arg0);
      }





      inline
      bool is_bool2nat_function_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bool2nat_function_function_symbol(application(e).head());
        }
        return false;
      }




      inline
      function_symbol_vector bag_generate_functions_code(const sort_expression& s)
      {
        function_symbol_vector result;
        result.push_back(bagconstructor(s));
        result.push_back(emptybag(s));
        result.push_back(bagfbag(s));
        result.push_back(bagcomprehension(s));
        result.push_back(bagcount(s));
        result.push_back(bagin(s));
        result.push_back(bagjoin(s));
        result.push_back(bagintersect(s));
        result.push_back(bagdifference(s));
        result.push_back(bag2set(s));
        result.push_back(set2bag(s));
        result.push_back(zero_function(s));
        result.push_back(one_function(s));
        result.push_back(add_function(s));
        result.push_back(min_function(s));
        result.push_back(monus_function(s));
        result.push_back(nat2bool_function(s));
        result.push_back(bool2nat_function(s));
        return result;
      }





      inline
      data_expression right(const data_expression& e)
      {
        ((is_bagconstructor_application(e) || is_bagcount_application(e) || is_bagin_application(e) || is_bagjoin_application(e) || is_bagintersect_application(e) || is_bagdifference_application(e) || is_add_function_application(e) || is_min_function_application(e) || is_monus_function_application(e)) ? static_cast<void> (0) : __assert_fail ("is_bagconstructor_application(e) || is_bagcount_application(e) || is_bagin_application(e) || is_bagjoin_application(e) || is_bagintersect_application(e) || is_bagdifference_application(e) || is_add_function_application(e) || is_min_function_application(e) || is_monus_function_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h", 1123, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg(const data_expression& e)
      {
        ((is_bagfbag_application(e) || is_bagcomprehension_application(e) || is_bag2set_application(e) || is_set2bag_application(e) || is_zero_function_application(e) || is_one_function_application(e) || is_nat2bool_function_application(e) || is_bool2nat_function_application(e)) ? static_cast<void> (0) : __assert_fail ("is_bagfbag_application(e) || is_bagcomprehension_application(e) || is_bag2set_application(e) || is_set2bag_application(e) || is_zero_function_application(e) || is_one_function_application(e) || is_nat2bool_function_application(e) || is_bool2nat_function_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h", 1135, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression left(const data_expression& e)
      {
        ((is_bagconstructor_application(e) || is_bagcount_application(e) || is_bagin_application(e) || is_bagjoin_application(e) || is_bagintersect_application(e) || is_bagdifference_application(e) || is_add_function_application(e) || is_min_function_application(e) || is_monus_function_application(e)) ? static_cast<void> (0) : __assert_fail ("is_bagconstructor_application(e) || is_bagcount_application(e) || is_bagin_application(e) || is_bagjoin_application(e) || is_bagintersect_application(e) || is_bagdifference_application(e) || is_add_function_application(e) || is_min_function_application(e) || is_monus_function_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h", 1147, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }




      inline
      data_equation_vector bag_generate_equations_code(const sort_expression& s)
      {
        variable vb("b",sort_fbag::fbag(s));
        variable vc("c",sort_fbag::fbag(s));
        variable ve("e",s);
        variable vf("f",make_function_sort(s, sort_nat::nat()));
        variable vg("g",make_function_sort(s, sort_nat::nat()));
        variable vh("h",make_function_sort(s, sort_bool::bool_()));
        variable vs("s",sort_fset::fset(s));
        variable vx("x",bag(s));
        variable vy("y",bag(s));
        variable vd("d",s);

        data_equation_vector result;
        result.push_back(data_equation(variable_list(), emptybag(s), bagconstructor(s, zero_function(s), sort_fbag::fbag_empty(s))));
        result.push_back(data_equation(atermpp::make_vector(vb), bagfbag(s, vb), bagconstructor(s, zero_function(s), vb)));
        result.push_back(data_equation(atermpp::make_vector(vf), bagcomprehension(s, vf), bagconstructor(s, vf, sort_fbag::fbag_empty(s))));
        result.push_back(data_equation(atermpp::make_vector(vb, ve, vf), bagcount(s, ve, bagconstructor(s, vf, vb)), sort_nat::swap_zero(vf(ve), sort_fbag::fbagcount(s, ve, vb))));
        result.push_back(data_equation(atermpp::make_vector(ve, vx), bagin(s, ve, vx), greater(bagcount(s, ve, vx), sort_nat::c0())));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vf, vg), equal_to(vf, vg), equal_to(bagconstructor(s, vf, vb), bagconstructor(s, vg, vc)), equal_to(vb, vc)));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vf, vg), not_equal_to(vf, vg), equal_to(bagconstructor(s, vf, vb), bagconstructor(s, vg, vc)), forall(atermpp::make_vector(vd), equal_to(bagcount(s, vd, bagconstructor(s, vf, vb)), bagcount(s, vd, bagconstructor(s, vg, vc))))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), less(vx, vy), sort_bool::and_(less_equal(vx, vy), not_equal_to(vx, vy))));
        result.push_back(data_equation(atermpp::make_vector(vx, vy), less_equal(vx, vy), equal_to(bagintersect(s, vx, vy), vx)));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vf, vg), bagjoin(s, bagconstructor(s, vf, vb), bagconstructor(s, vg, vc)), bagconstructor(s, add_function(s, vf, vg), sort_fbag::fbagjoin(s, vf, vg, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vf, vg), bagintersect(s, bagconstructor(s, vf, vb), bagconstructor(s, vg, vc)), bagconstructor(s, min_function(s, vf, vg), sort_fbag::fbagintersect(s, vf, vg, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vc, vf, vg), bagdifference(s, bagconstructor(s, vf, vb), bagconstructor(s, vg, vc)), bagconstructor(s, monus_function(s, vf, vg), sort_fbag::fbagdifference(s, vf, vg, vb, vc))));
        result.push_back(data_equation(atermpp::make_vector(vb, vf), bag2set(s, bagconstructor(s, vf, vb)), sort_set::setconstructor(s, nat2bool_function(s, vf), sort_fbag::fbag2fset(s, vf, vb))));
        result.push_back(data_equation(atermpp::make_vector(vh, vs), set2bag(s, sort_set::setconstructor(s, vh, vs)), bagconstructor(s, bool2nat_function(s, vh), sort_fbag::fset2fbag(s, vs))));
        result.push_back(data_equation(atermpp::make_vector(ve), zero_function(s, ve), sort_nat::c0()));
        result.push_back(data_equation(atermpp::make_vector(ve), one_function(s, ve), sort_nat::cnat(sort_pos::c1())));
        result.push_back(data_equation(variable_list(), equal_to(zero_function(s), one_function(s)), sort_bool::false_()));
        result.push_back(data_equation(variable_list(), equal_to(one_function(s), zero_function(s)), sort_bool::false_()));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg), add_function(s, vf, vg)(ve), sort_nat::plus(vf(ve), vg(ve))));
        result.push_back(data_equation(atermpp::make_vector(vf), add_function(s, vf, zero_function(s)), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), add_function(s, zero_function(s), vf), vf));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg), min_function(s, vf, vg)(ve), sort_nat::minimum(vf(ve), vg(ve))));
        result.push_back(data_equation(atermpp::make_vector(vf), min_function(s, vf, vf), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), min_function(s, vf, zero_function(s)), zero_function(s)));
        result.push_back(data_equation(atermpp::make_vector(vf), min_function(s, zero_function(s), vf), zero_function(s)));
        result.push_back(data_equation(atermpp::make_vector(ve, vf, vg), monus_function(s, vf, vg)(ve), sort_nat::monus(vf(ve), vg(ve))));
        result.push_back(data_equation(atermpp::make_vector(vf), monus_function(s, vf, vf), zero_function(s)));
        result.push_back(data_equation(atermpp::make_vector(vf), monus_function(s, vf, zero_function(s)), vf));
        result.push_back(data_equation(atermpp::make_vector(vf), monus_function(s, zero_function(s), vf), zero_function(s)));
        result.push_back(data_equation(atermpp::make_vector(ve, vf), nat2bool_function(s, vf)(ve), greater(vf(ve), sort_nat::c0())));
        result.push_back(data_equation(variable_list(), nat2bool_function(s, zero_function(s)), sort_set::false_function(s)));
        result.push_back(data_equation(variable_list(), nat2bool_function(s, one_function(s)), sort_set::true_function(s)));
        result.push_back(data_equation(atermpp::make_vector(ve, vh), bool2nat_function(s, vh)(ve), if_(vh(ve), sort_nat::cnat(sort_pos::c1()), sort_nat::c0())));
        result.push_back(data_equation(variable_list(), bool2nat_function(s, sort_set::false_function(s)), zero_function(s)));
        result.push_back(data_equation(variable_list(), bool2nat_function(s, sort_set::true_function(s)), one_function(s)));
        return result;
      }

    }

  }

}
# 41 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard.h" 1
# 42 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 1
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h"
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 36 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 37 "/usr/include/boost/assert.hpp" 2 3 4
# 18 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2

# 1 "/usr/include/boost/type_traits/make_unsigned.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_signed.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4

namespace boost {



namespace detail{



template <class T>
struct is_signed_helper
{
   typedef typename remove_cv<T>::type no_cv_t;
   static const bool value = (static_cast<no_cv_t>(-1) < 0);
};

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;

};
# 113 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
}






template< typename T > struct is_signed : ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 126 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4
# 15 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_unsigned.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 20 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4

namespace boost {



namespace detail{



template <class T>
struct is_ununsigned_helper
{
   typedef typename remove_cv<T>::type no_cv_t;
   static const bool value = (static_cast<no_cv_t>(-1) > 0);
};

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;
};
# 109 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
}






template< typename T > struct is_unsigned : ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { };


}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 122 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/add_volatile.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/add_volatile.hpp" 2 3 4

namespace boost {
# 33 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
template< typename T > struct add_volatile { typedef T volatile type; };






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


}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 46 "/usr/include/boost/type_traits/add_volatile.hpp" 2 3 4
# 23 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/type_trait_def.hpp" 2 3 4
# 30 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4

namespace boost {

namespace detail {

template <class T>
struct make_unsigned_imp
{
   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_39;


   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_43;




   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename mpl::if_c<
      (::boost::type_traits::ice_and<
         ::boost::is_unsigned<T>::value,
         ::boost::is_integral<T>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
      T,
      typename mpl::if_c<
         (::boost::type_traits::ice_and<
            ::boost::is_integral<T>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
         ::value),
         typename mpl::if_<
            is_same<t_no_cv, signed char>,
            unsigned char,
            typename mpl::if_<
               is_same<t_no_cv, short>,
               unsigned short,
               typename mpl::if_<
                  is_same<t_no_cv, int>,
                  unsigned int,
                  typename mpl::if_<
                     is_same<t_no_cv, long>,
                     unsigned long,

                     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 { typedef typename boost::detail::make_unsigned_imp<T>::type type; };

}

# 1 "/usr/include/boost/type_traits/detail/type_trait_undef.hpp" 1 3 4
# 135 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
# 20 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2
# 1 "/usr/include/boost/type_traits/is_floating_point.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_floating_point.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/template_arity_spec.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/bool_trait_def.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/is_floating_point.hpp" 2 3 4

namespace boost {


template< typename T > struct is_floating_point : ::boost::integral_constant<bool,false> { };
template<> struct is_floating_point< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_floating_point< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const volatile > : ::boost::integral_constant<bool,true> { };
template<> struct is_floating_point< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const volatile > : ::boost::integral_constant<bool,true> { };

}

# 1 "/usr/include/boost/type_traits/detail/bool_trait_undef.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_floating_point.hpp" 2 3 4
# 21 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/join.h" 1
# 15 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/join.h"
namespace mcrl2 {

namespace core {

namespace detail {
# 28 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/join.h"
  template <typename T, typename OutputIterator, typename MatchFunction, typename AccessorFunction>
  void split(T t, OutputIterator i, MatchFunction match, AccessorFunction lhs, AccessorFunction rhs)
  {
    if (match(t))
    {
      split(lhs(t), i, match, lhs, rhs);
      split(rhs(t), i, match, lhs, rhs);
    }
    else
    {
      *i++ = t;
    }
  }
# 49 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/join.h"
  template <typename T, typename FwdIt, typename BinaryOperation>
  T join(FwdIt first, FwdIt last, BinaryOperation op, T empty_sequence_result)
  {
    if(first == last)
      return empty_sequence_result;
    T result = *first++;
    while(first != last)
    {
      result = op(result, *first++);
    }
    return result;
  }

}

}

}
# 23 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2
# 31 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h"
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/real.h" 1
# 32 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/list.h" 1
# 33 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2

# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/bag.h" 1
# 35 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h" 2


namespace mcrl2 {

  namespace data {


    namespace detail {


      inline std::vector< char > string_to_vector_number(std::string const& s) {
        ((s.size() > 0) ? static_cast<void> (0) : __assert_fail ("s.size() > 0", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 46, __PRETTY_FUNCTION__));
        std::vector< char > result;

        result.reserve(s.size());

        for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) {
          (('0' <= *i && *i <= '9') ? static_cast<void> (0) : __assert_fail ("'0' <= *i && *i <= '9'", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 52, __PRETTY_FUNCTION__));

          result.push_back(*i - '0');
        }

        return result;
      }



      inline std::string vector_number_to_string(std::vector< char > const& v) {
        ((v.size() > 0) ? static_cast<void> (0) : __assert_fail ("v.size() > 0", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 63, __PRETTY_FUNCTION__));
        std::string result;

        result.reserve(v.size());

        for (std::vector< char >::const_iterator i = v.begin(); i != v.end(); ++i) {
          result.push_back(*i + '0');
        }

        return result;
      }


      template< typename T >
      inline std::string as_decimal_string(T t) {
        if (t != 0) {
          std::string result;

          while (0 < t) {
            result.append(1, '0' + static_cast< char >(t % 10));

            t /= 10;
          }

          return std::string(result.rbegin(), result.rend());
        }

        return "0";
      }




      inline void decimal_number_divide_by_two(std::vector< char >& number)
      {
        ((0 < number.size()) ? static_cast<void> (0) : __assert_fail ("0 < number.size()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 98, __PRETTY_FUNCTION__));

        std::vector< char > result(number.size(), 0);
        std::vector< char >::iterator j(result.begin());

        if (2 <= number[0]) {
          *(j++) = number[0] / 2;
        }

        for (std::vector< char >::const_iterator i = number.begin() + 1; i != number.end(); ++i, ++j) {

          *j = 5 * (*(i - 1) % 2) + *i / 2;
        }

        result.resize(j - result.begin());

        number.swap(result);
      }




      inline void decimal_number_multiply_by_two(std::vector< char >& number)
      {
        ((0 < number.size()) ? static_cast<void> (0) : __assert_fail ("0 < number.size()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 122, __PRETTY_FUNCTION__));

        std::vector< char > result(number.size() + 2, 0);
        std::vector< char >::iterator j(result.begin());

        if (5 <= number[0]) {
          *(j++) = number[0] / 5;
        }

        for (std::vector< char >::const_iterator i = number.begin(); i < number.end(); ++i, ++j) {

          if (i == number.end() - 1)
          {
            *j = 2 * (*i % 5);
          }
          else
          {
            *j = 2 * (*i % 5) + *(i+1) / 5;
          }
        }

        result.resize(j - result.begin());

        number.swap(result);
      }




      inline void decimal_number_increment(std::vector< char >& number) {
        ((0 < number.size()) ? static_cast<void> (0) : __assert_fail ("0 < number.size()", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 152, __PRETTY_FUNCTION__));

        for (std::vector< char >::reverse_iterator i = number.rbegin(); i != number.rend(); ++i) {
          if (*i < 9) {
            ++(*i);

            return;
          }
          else {
            *i = 0;
          }
        }

        number.insert(number.begin(), 1);
      }

    }


    namespace sort_bool{


      inline data_expression bool_(bool b) {
        return (b) ? sort_bool::true_() : sort_bool::false_();
      }



      inline bool is_boolean_constant(data_expression const& b)
      {
        return sort_bool::is_true_function_symbol(b) ||
               sort_bool::is_false_function_symbol(b);
      }
    }

    namespace sort_pos {


      template < typename T >
      inline typename boost::enable_if< typename boost::is_integral< T >::type, data_expression >::type
      pos(const T t) {
        ((0 < t) ? static_cast<void> (0) : __assert_fail ("0 < t", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 193, __PRETTY_FUNCTION__));

        std::vector< bool > bits;
        bits.reserve(8 * sizeof(T));

        for (T u = t; 1 < u; u /= 2)
        {
          bits.push_back(u % 2 != 0);
        }

        data_expression result(sort_pos::c1());

        for (std::vector< bool >::reverse_iterator i = bits.rbegin(); i != bits.rend(); ++i) {
          result = sort_pos::cdub(sort_bool::bool_(*i), result);
        }

        return result;
      }



      inline data_expression pos(std::string const& n) {
        std::vector< char > number_as_vector(detail::string_to_vector_number(n));

        std::vector< bool > bits;
        bits.reserve(number_as_vector.size());

        while (0 < number_as_vector.size() && !((number_as_vector.size() == 1) && number_as_vector[0] == 1)) {
          bits.push_back((static_cast< int >(*number_as_vector.rbegin()) % 2 != 0));

          detail::decimal_number_divide_by_two(number_as_vector);
        }

        data_expression result(sort_pos::c1());

        for (std::vector< bool >::reverse_iterator i = bits.rbegin(); i != bits.rend(); ++i) {
          result = sort_pos::cdub(sort_bool::bool_(*i), result);
        }

        return result;
      }



      inline bool is_positive_constant(data_expression const& n)
      {
        return sort_pos::is_c1_function_symbol(n) ||
               ( sort_pos::is_cdub_application(n) &&
                 sort_bool::is_boolean_constant(sort_pos::bit(n)) &&
                 sort_pos::is_positive_constant(sort_pos::number(n))
               );
      }







      inline
      std::string positive_constant_as_string(data_expression n)
      {
        std::vector<bool> bits;

        while(sort_pos::is_cdub_application(n))
        {
          bits.push_back(sort_bool::is_true_function_symbol(sort_pos::bit(n)));
          n = sort_pos::number(n);
        }

        ((sort_pos::is_c1_function_symbol(n)) ? static_cast<void> (0) : __assert_fail ("sort_pos::is_c1_function_symbol(n)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 263, __PRETTY_FUNCTION__));

        std::vector< char > result = detail::string_to_vector_number("1");

        for(std::vector<bool>::reverse_iterator i = bits.rbegin(); i != bits.rend(); ++i)
        {
          detail::decimal_number_multiply_by_two(result);
          if(*i)
          {
            detail::decimal_number_increment(result);
          }
        }

        return detail::vector_number_to_string(result);
      }
    }

    namespace sort_nat {


      template < typename T >
      inline typename boost::enable_if< typename boost::is_integral< T >::type, data_expression >::type
      nat(T t) {
        ((0 <= t) ? static_cast<void> (0) : __assert_fail ("0 <= t", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 286, __PRETTY_FUNCTION__));
        return (t == 0) ? sort_nat::c0() : static_cast< data_expression const& >(sort_nat::cnat(sort_pos::pos(t)));
      }



      inline data_expression nat(std::string const& n) {
        return (n == "0") ? sort_nat::c0() : static_cast< data_expression const& >(sort_nat::cnat(sort_pos::pos(n)));
      }



      inline bool is_natural_constant(data_expression const& n)
      {
        return sort_nat::is_c0_function_symbol(n) ||
               ( sort_nat::is_cnat_application(n) &&
                 sort_pos::is_positive_constant(sort_nat::arg(n))
               );
      }





      inline std::string natural_constant_as_string(data_expression const& n)
      {
        ((is_natural_constant(n)) ? static_cast<void> (0) : __assert_fail ("is_natural_constant(n)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 312, __PRETTY_FUNCTION__));
        if(sort_nat::is_c0_function_symbol(n))
        {
          return "0";
        }
        else
        {
          return sort_pos::positive_constant_as_string(sort_nat::arg(n));
        }
      }
    }

    namespace sort_int {


      template < typename T >
      inline typename boost::enable_if< typename boost::is_integral< T >::type, data_expression >::type
      int_(T t) {
        std::string number(detail::as_decimal_string< typename boost::make_unsigned< T >::type >((0 <= t) ? t : -t));

        return (t < 0) ? sort_int::cneg(sort_pos::pos(-t)) :
            static_cast< data_expression const& >(sort_int::cint(sort_nat::nat(t)));
      }




      inline data_expression int_(std::string const& n) {
        return (n[0] == '-') ? sort_int::cneg(sort_pos::pos(n.substr(1))) :
            static_cast< data_expression const& >(sort_int::cint(sort_nat::nat(n)));
      }



      inline bool is_integer_constant(data_expression const& n)
      {
        return ( sort_int::is_cint_application(n) &&
                 sort_nat::is_natural_constant(sort_int::arg(n)) ) ||
               ( sort_int::is_cneg_application(n) &&
                 sort_pos::is_positive_constant(sort_int::arg(n))
               );
      }





      inline std::string integer_constant_as_string(data_expression const& n)
      {
        ((is_integer_constant(n)) ? static_cast<void> (0) : __assert_fail ("is_integer_constant(n)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 361, __PRETTY_FUNCTION__));
        if(sort_int::is_cint_application(n))
        {
          return sort_nat::natural_constant_as_string(sort_int::arg(n));
        }
        else
        {
          return "-" + sort_pos::positive_constant_as_string(sort_int::arg(n));
        }
      }
    }

    namespace sort_real {


      template < typename T >
      inline typename boost::enable_if< typename boost::is_integral< T >::type, data_expression >::type
      real_(T t) {
        return sort_real::creal(sort_int::int_(t), sort_pos::c1());
      }




      template < typename T >
      inline typename boost::enable_if< typename boost::is_integral< T >::type, data_expression >::type
      real_(T numerator, T denominator) {
        return sort_real::creal(sort_int::int_(numerator), sort_pos::pos(denominator));
      }




      inline data_expression real_(std::string const& n) {
        return sort_real::creal(sort_int::int_(n), sort_pos::c1());
      }
    }





    inline data_expression number(sort_expression const& s, std::string const& n)
    {
      if (s == sort_pos::pos()) {
        return sort_pos::pos(n);
      }
      else if (s == sort_nat::nat()) {
        return sort_nat::nat(n);
      }
      else if (s == sort_int::int_()) {
        return sort_int::int_(n);
      }

      return sort_real::real_(n);
    }





    inline bool is_convertible(sort_expression const& s1, sort_expression const& s2)
    {
      if (s1 != s2)
      {
        if (s2 == sort_real::real_()) {
          return s1 == sort_int::int_() || s1 == sort_nat::nat() || s1 == sort_pos::pos();
        }
        else if (s2 == sort_int::int_()) {
          return s1 == sort_nat::nat() || s1 == sort_pos::pos();
        }
        else if (s2 == sort_nat::nat()) {
          return s1 == sort_pos::pos();
        }

        return false;
      }

      return true;
    }

    namespace sort_list {






      template < typename Sequence >
      inline
      application list(const sort_expression& s,
                       Sequence const& range,
                       typename atermpp::detail::enable_if_container< Sequence, data_expression >::type* = 0)
      {
        data_expression list_expression(nil(s));
        std::vector< data_expression > elements(range.begin(), range.end());

        for (std::vector< data_expression >::reverse_iterator i = elements.rbegin(); i != elements.rend(); ++i) {
          ((is_convertible(i->sort(), s)) ? static_cast<void> (0) : __assert_fail ("is_convertible(i->sort(), s)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 459, __PRETTY_FUNCTION__));

          list_expression = sort_list::cons_(s, *i, list_expression);
        }

        return static_cast< application >(list_expression);
      }



      inline
      core::identifier_string const& list_enumeration_name()
      {
        static core::identifier_string list_enumeration_name = data::detail::initialise_static_expression(list_enumeration_name, core::identifier_string("@ListEnum"));
        return list_enumeration_name;
      }




      inline
      function_symbol list_enumeration(const sort_expression& s)
      {
        function_symbol list_enumeration(list_enumeration_name(), s);
        return list_enumeration;
      }




      inline
      bool is_list_enumeration_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == list_enumeration_name();
        }
        return false;
      }
# 506 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h"
      template <typename Sequence>
      inline
      data_expression list_enumeration(const sort_expression& s,
                                       Sequence const& range,
                                       typename atermpp::detail::enable_if_container< Sequence, data_expression >::type* = 0)
      {
        if(range.empty())
        {
          return list_enumeration(s);
        }
        else
        {
          sort_expression_vector v(range.size(), range.begin()->sort());

          return application(list_enumeration(function_sort(v,s)), range);
        }
      }





      inline
      data_expression list_enumeration(const sort_expression& s, data_expression_list const& range)
      {
        if(range.empty())
        {
          return list_enumeration(s);
        }
        else
        {
          sort_expression_vector v(range.size(), range.begin()->sort());

          return application(list_enumeration(function_sort(v,s)), range);
        }
      }





      inline
      bool is_list_enumeration_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_list_enumeration_function_symbol(application(e).head());
        }
        return false;
      }
    }

    namespace sort_set {


      inline
      core::identifier_string const& set_enumeration_name()
      {
        static core::identifier_string set_enumeration_name = data::detail::initialise_static_expression(set_enumeration_name, core::identifier_string("@SetEnum"));
        return set_enumeration_name;
      }




      inline
      function_symbol set_enumeration(const sort_expression& s)
      {
        function_symbol set_enumeration(set_enumeration_name(), s);
        return set_enumeration;
      }




      inline
      bool is_set_enumeration_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == set_enumeration_name();
        }
        return false;
      }
# 598 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h"
      template <typename Sequence>
      inline
      data_expression set_enumeration(const sort_expression& s,
                                      Sequence const& range,
                                      typename atermpp::detail::enable_if_container< Sequence, data_expression >::type* = 0)
      {
        if(range.empty())
        {
          return set_enumeration(s);
        }
        else
        {
          sort_expression_vector v(range.size(), range.begin()->sort());

          return application(set_enumeration(function_sort(v,s)), range);
        }
      }





      inline
      data_expression set_enumeration(const sort_expression& s,
                                      data_expression_list const& range)
      {
        if(range.empty())
        {
          return set_enumeration(s);
        }
        else
        {
          sort_expression_vector v(range.size(), range.begin()->sort());

          return application(set_enumeration(function_sort(v,s)), range);
        }
      }





      inline
      bool is_set_enumeration_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_set_enumeration_function_symbol(application(e).head());
        }
        return false;
      }
    }

    namespace sort_fset {







      template < typename Sequence >
      inline
      application fset(const sort_expression& s,
                       Sequence const& range,
                       typename atermpp::detail::enable_if_container< Sequence, data_expression >::type* = 0)
      {
        data_expression fset_expression(sort_fset::fset_empty(s));



        for (typename Sequence::const_reverse_iterator i = range.rbegin(); i != range.rend(); ++i) {
          ((is_convertible(i->sort(), s)) ? static_cast<void> (0) : __assert_fail ("is_convertible(i->sort(), s)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 670, __PRETTY_FUNCTION__));

          fset_expression = sort_fset::fsetinsert(s, *i, fset_expression);
        }

        return static_cast< application >(fset_expression);
      }





      inline
      application fset(const sort_expression& s,
                       data_expression_list const& range)
      {
        return fset(s, atermpp::convert<data_expression_vector, data_expression_list>(range));
      }

    }

    namespace sort_bag {


      inline
      core::identifier_string const& bag_enumeration_name()
      {
        static core::identifier_string bag_enumeration_name = data::detail::initialise_static_expression(bag_enumeration_name, core::identifier_string("@BagEnum"));
        return bag_enumeration_name;
      }




      inline
      function_symbol bag_enumeration(const sort_expression& s)
      {
        function_symbol bag_enumeration(bag_enumeration_name(), s);
        return bag_enumeration;
      }




      inline
      bool is_bag_enumeration_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == bag_enumeration_name();
        }
        return false;
      }
# 731 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h"
      template <typename Sequence>
      inline
      data_expression bag_enumeration(const sort_expression& s,
                                      Sequence const& range,
                                      typename atermpp::detail::enable_if_container< Sequence, data_expression >::type* = 0)
      {
        if(range.empty())
        {
          return bag_enumeration(s);
        }
        else
        {
          ((range.size() % 2 == 0) ? static_cast<void> (0) : __assert_fail ("range.size() % 2 == 0", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 743, __PRETTY_FUNCTION__));
          sort_expression t(range.begin()->sort());

          sort_expression_vector v;

          for(size_t i = 0; i < range.size() / 2; ++i)
          {
            v.push_back(t);
            v.push_back(sort_nat::nat());
          }

          return application(bag_enumeration(function_sort(v,s)), range);
        }
      }





      inline
      data_expression bag_enumeration(const sort_expression& s,
                                      data_expression_list const& range)
      {
        if(range.empty())
        {
          return bag_enumeration(s);
        }
        else
        {
          ((range.size() % 2 == 0) ? static_cast<void> (0) : __assert_fail ("range.size() % 2 == 0", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 772, __PRETTY_FUNCTION__));
          sort_expression t(range.begin()->sort());
          sort_expression_vector v;

          for(size_t i = 0; i < range.size() / 2; ++i)
          {
            v.push_back(t);
            v.push_back(sort_nat::nat());
          }

          return application(bag_enumeration(function_sort(v,s)), range);
        }
      }





      inline
      bool is_bag_enumeration_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_bag_enumeration_function_symbol(application(e).head());
        }
        return false;
      }

    }

    namespace sort_fbag {






      template < typename Sequence >
      inline
      application fbag(const sort_expression& s, Sequence const& range,
                       typename atermpp::detail::enable_if_container< Sequence, data_expression >::type* = 0)
      {
        data_expression fbag_expression(sort_fbag::fbag_empty(s));





        for (typename Sequence::const_reverse_iterator i = range.rbegin(); i != range.rend(); ++i, ++i)
        {
          ((is_convertible(boost::next(i, 1)->sort(), s)) ? static_cast<void> (0) : __assert_fail ("is_convertible(boost::next(i, 1)->sort(), s)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h", 822, __PRETTY_FUNCTION__));
          fbag_expression = sort_fbag::fbagcinsert(s, *boost::next(i, 1), *i, fbag_expression);
        }

        return static_cast< application >(fbag_expression);
      }





      inline
      application fbag(const sort_expression& s, data_expression_list const& range)
      {
        return fbag(s, atermpp::convert<data_expression_vector, data_expression_list>(range));
      }
    }


    inline bool is_nil(atermpp::aterm_appl t)
    {
      return t == core::detail::gsMakeNil();
    }



    inline
    bool
    is_system_defined(const sort_expression& s)
    {
      return sort_bool::is_bool(s) || sort_real::is_real(s)
          || sort_int::is_int(s) || sort_nat::is_nat(s) || sort_pos::is_pos(s)
          || is_container_sort(s) || is_structured_sort(s);
    }
# 864 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/standard_utility.h"
    namespace lazy {



      inline data_expression not_(data_expression const& p)
      {
        if (p == sort_bool::true_()) {
          return sort_bool::false_();
        }
        else if (p == sort_bool::false_()) {
          return sort_bool::true_();
        }

        return sort_bool::not_(p);
      }





      inline data_expression or_(data_expression const& p, data_expression const& q)
      {
        if ((p == sort_bool::true_()) || (q == sort_bool::true_())) {
          return sort_bool::true_();
        }
        else if ((p == q) || (p == sort_bool::false_())) {
          return q;
        }
        else if (q == sort_bool::false_()) {
          return p;
        }

        return sort_bool::or_(p, q);
      }





      inline data_expression and_(data_expression const& p, data_expression const& q)
      {
        if ((p == sort_bool::false_()) || (q == sort_bool::false_())) {
          return sort_bool::false_();
        }
        else if ((p == q) || (p == sort_bool::true_())) {
          return q;
        }
        else if (q == sort_bool::true_()) {
          return p;
        }

        return sort_bool::and_(p, q);
      }





      inline data_expression implies(data_expression const& p, data_expression const& q)
      {
        if ((p == sort_bool::false_()) || (q == sort_bool::true_()) || (p == q)) {
          return sort_bool::true_();
        }
        else if (p == sort_bool::true_()) {
          return q;
        }
        else if (q == sort_bool::false_()) {
          return sort_bool::not_(p);
        }

        return sort_bool::implies(p, q);
      }





      inline data_expression equal_to(data_expression const& p, data_expression const& q)
      {
        if (p == q) {
          return sort_bool::true_();
        }

        return data::equal_to(p, q);
      }





      inline data_expression not_equal_to(data_expression const& p, data_expression const& q)
      {
        if (p == q) {
          return sort_bool::false_();
        }

        return data::not_equal_to(p, q);
      }





      template < typename ForwardTraversalIterator >
      inline data_expression join_or(ForwardTraversalIterator first, ForwardTraversalIterator last)
      {
        return core::detail::join(first, last, lazy::or_, static_cast< data_expression const& >(sort_bool::false_()));
      }





      template < typename ForwardTraversalIterator >
      inline data_expression join_and(ForwardTraversalIterator first, ForwardTraversalIterator last)
      {
        return core::detail::join(first, last, lazy::and_, static_cast< data_expression const& >(sort_bool::true_()));
      }
    }


  }

}
# 43 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2
# 1 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_update.h" 1
# 29 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_update.h"
namespace mcrl2 {

  namespace data {



      inline
      core::identifier_string const& function_update_name()
      {
        static core::identifier_string function_update_name = data::detail::initialise_static_expression(function_update_name, core::identifier_string("@func_update"));
        return function_update_name;
      }





      inline
      function_symbol function_update(const sort_expression& s, const sort_expression& t)
      {
        function_symbol function_update(function_update_name(), make_function_sort(make_function_sort(s, t), s, t, make_function_sort(s, t)));
        return function_update;
      }





      inline
      bool is_function_update_function_symbol(const atermpp::aterm_appl& e)
      {
        if (is_function_symbol(e))
        {
          return function_symbol(e).name() == function_update_name();
        }
        return false;
      }
# 74 "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_update.h"
      inline
      application function_update(const sort_expression& s, const sort_expression& t, const data_expression& arg0, const data_expression& arg1, const data_expression& arg2)
      {
        return function_update(s, t)(arg0, arg1, arg2);
      }





      inline
      bool is_function_update_application(const atermpp::aterm_appl& e)
      {
        if (is_application(e))
        {
          return is_function_update_function_symbol(application(e).head());
        }
        return false;
      }





      inline
      function_symbol_vector function_update_generate_functions_code(const sort_expression& s, const sort_expression& t)
      {
        function_symbol_vector result;
        result.push_back(function_update(s, t));
        return result;
      }





      inline
      data_expression arg1(const data_expression& e)
      {
        ((is_function_update_application(e)) ? static_cast<void> (0) : __assert_fail ("is_function_update_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_update.h", 113, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 0);
      }






      inline
      data_expression arg2(const data_expression& e)
      {
        ((is_function_update_application(e)) ? static_cast<void> (0) : __assert_fail ("is_function_update_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_update.h", 125, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 1);
      }






      inline
      data_expression arg3(const data_expression& e)
      {
        ((is_function_update_application(e)) ? static_cast<void> (0) : __assert_fail ("is_function_update_application(e)", "/scratch/mcrl2_regressiontest/trunk/libraries/data/include/mcrl2/data/function_update.h", 137, __PRETTY_FUNCTION__));
        return *boost::next(static_cast< application >(e).arguments().begin(), 2);
      }





      inline
      data_equation_vector function_update_generate_equations_code(const sort_expression& s, const sort_expression& t)
      {
        variable vx("x",s);
        variable vy("y",s);
        variable vv("v",t);
        variable vw("w",t);
        variable vf("f",make_function_sort(s, t));

        data_equation_vector result;
        result.push_back(data_equation(atermpp::make_vector(vf, vv, vx), equal_to(vf(vx), vv), function_update(s, t, vf, vx, vv), vf));
        result.push_back(data_equation(atermpp::make_vector(vf, vv, vw, vx), function_update(s, t, function_update(s, t, vf, vx, vw), vx, vv), function_update(s, t, vf, vx, vv)));
        result.push_back(data_equation(atermpp::make_vector(vf, vv, vw, vx, vy), greater(vx, vy), function_update(s, t, function_update(s, t, vf, vy, vw), vx, vv), function_update(s, t, function_update(s, t, vf, vx, vv), vy, vw)));
        result.push_back(data_equation(atermpp::make_vector(vf, vv, vx, vy), not_equal_to(vx, vy), function_update(s, t, vf, vx, vv)(vy), vf(vy)));
        result.push_back(data_equation(atermpp::make_vector(vf, vv, vx), function_update(s, t, vf, vx, vv)(vx), vv));
        return result;
      }

  }

}
# 44 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h" 2

namespace mcrl2 {
  namespace core {
    namespace detail {




inline data::data_expression bool_to_numeric(data::data_expression const& e, data::sort_expression const& s)
{

  return data::if_(e, data::function_symbol("1", s), data::function_symbol("0", s));
}

static inline
ATermAppl gsMakeEmptyDataSpec()
{
  return gsMakeDataSpec(
    gsMakeSortSpec((ATempty)),
    gsMakeConsSpec((ATempty)),
    gsMakeMapSpec((ATempty)),
    gsMakeDataEqnSpec((ATempty))
  );
}






static void PrintPart__C(FILE* OutStream, const ATerm Part,
  t_pp_format pp_format);






static void PrintPart_Appl_C(FILE* OutStream,
  const ATermAppl Part, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 98 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintPart_List_C(FILE* OutStream,
  const ATermList Parts, t_pp_format pp_format, bool ShowSorts, int PrecLevel,
  const char *Terminator, const char *Separator);
# 114 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintPart_BagEnum_C(FILE* OutStream,
  const ATermList Parts, t_pp_format pp_format, bool ShowSorts, int PrecLevel,
  const char *Terminator, const char *Separator);
# 131 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintEqns_C(FILE* OutStream,
  const ATermList Eqns, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 147 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintDecls_C(FILE* OutStream,
  const ATermList Decls, t_pp_format pp_format,
  const char *Terminator, const char *Separator);
# 163 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintDecl_C(FILE* OutStream,
  const ATermAppl Decl, t_pp_format pp_format, const bool ShowSorts);
# 175 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintSortExpr_C(FILE* OutStream,
  const ATermAppl SortExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 191 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintDataExpr_C(FILE* OutStream,
  const ATermAppl DataExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 207 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintProcExpr_C(FILE* OutStream,
  const ATermAppl ProcExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 223 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintStateFrm_C(FILE* OutStream,
  const ATermAppl StateFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 239 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintRegFrm_C(FILE* OutStream,
  const ATermAppl RegFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 255 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintActFrm_C(FILE* OutStream,
  const ATermAppl ActFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 271 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintPBExpr_C(FILE* OutStream,
  const ATermAppl StateFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel);
# 287 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void PrintLinearProcessSummand_C(FILE* OutStream,
  const ATermAppl LinearProcessSummand, t_pp_format pp_format, bool ShowSorts);
# 297 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static void IndentedATerm_C(FILE* OutStream, const ATerm Term, unsigned int Nesting = 0);





static void AFun_C(FILE* OutStream, const AFun Fun);


static ATermList GetAssignmentsRHS(ATermList Assignments);





static ATermList gsGroupDeclsBySort(ATermList Decls);






static bool gsHasConsistentContext(const ATermTable DataVarDecls,
  const ATermAppl Part);
# 330 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static bool gsHasConsistentContextList(const ATermTable DataVarDecls,
  const ATermList Parts);
# 341 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
static bool gsIsOpIdNumericUpCast(ATermAppl DataExpr);


static bool gsIsIdListEnum(ATermAppl DataExpr);


static bool gsIsIdSetEnum(ATermAppl DataExpr);


static bool gsIsIdBagEnum(ATermAppl DataExpr);


static bool gsIsIdFuncUpdate(ATermAppl DataExpr);


static bool gsIsIdPrefix(ATermAppl DataExpr, int ArgsLength);


static bool gsIsIdInfix(ATermAppl DataExpr, int ArgsLength);


static int gsPrecIdPrefix();



static int gsPrecIdInfix(ATermAppl IdName);



static int gsPrecIdInfixLeft(ATermAppl IdName);



static int gsPrecIdInfixRight(ATermAppl IdName);







inline static void fprints_C(FILE* OutStream,
  const char *Value)


{




  fprintf(OutStream, "%s", Value);



}

inline static void dbg_prints_C(const char *Value)
{
static_cast<void>(Value);
# 410 "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h"
}

static void AFun_C(FILE* OutStream, const AFun fun)
{
  if ((((at_lookup_table_alias[(fun)]->header) & (1<<3)) ? ATtrue : ATfalse)) {
    fprints_C(OutStream, "\"");
  }
  fprints_C(OutStream, (at_lookup_table[(fun)]->name));
  if ((((at_lookup_table_alias[(fun)]->header) & (1<<3)) ? ATtrue : ATfalse)) {
    fprints_C(OutStream, "\"");
  }
}

static void IndentedATerm_C(FILE* OutStream, const ATerm term, unsigned int nesting)
{
  std::string prefix(2*nesting, ' ');
  if (((unsigned int)((((term)->header) & (((1 << 3)-1) << 4)) >> 4)) == 1L) {
    fprints_C(OutStream, prefix.c_str());
    ATermAppl appl = (ATermAppl) term;
    AFun fun = ((AFun)(((appl)->header) >> 34));
    AFun_C(OutStream, fun);
    unsigned int arity = ((unsigned int)((unsigned long)((at_lookup_table_alias[(fun)]->header) >> 34)));
    if (arity > 0) {
      fprints_C(OutStream, "(\n");
      for (unsigned int i = 0; i < arity; i++) {
        IndentedATerm_C(OutStream, (((ATermAppl)appl)->aterm.arg[i]), nesting+1);
        if (i+1 < arity) {
          fprints_C(OutStream, ",\n");
        }
      }
      fprints_C(OutStream, "\n");
      fprints_C(OutStream, prefix.c_str());
      fprints_C(OutStream, ")");
    }
  } else if (((unsigned int)((((term)->header) & (((1 << 3)-1) << 4)) >> 4)) == 4L) {
    fprints_C(OutStream, prefix.c_str());
    if (((ATbool)(((ATermList)(ATermList) term)->aterm.head == __null && ((ATermList)(ATermList) term)->aterm.tail == __null))) {
      fprints_C(OutStream, "[]");
    } else {
      fprints_C(OutStream, "[\n");
      for (ATermList l = (ATermList) term; !((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null)); l = (((ATermList)l)->aterm.tail)) {
        IndentedATerm_C(OutStream, (((ATermList)l)->aterm.head), nesting+1);
        if (!((ATbool)(((ATermList)(((ATermList)l)->aterm.tail))->aterm.head == __null && ((ATermList)(((ATermList)l)->aterm.tail))->aterm.tail == __null))) {
          fprints_C(OutStream, ",\n");
        }
      }
      fprints_C(OutStream, "\n");
      fprints_C(OutStream, prefix.c_str());
      fprints_C(OutStream, "]");
    }
  } else {
    fprints_C(OutStream, "ERROR: term is not an ATermAppl or ATermList");
  }
}

void PrintPart__C(FILE* OutStream, const ATerm Part,
  t_pp_format pp_format)
{
  if (pp_format == ppInternal) {

    ATwriteToTextFile(Part, OutStream);
    fprintf(OutStream, "\n");



  } else if (pp_format == ppInternalDebug) {
    IndentedATerm_C(OutStream, Part);
  } else {
    if (((unsigned int)((((Part)->header) & (((1 << 3)-1) << 4)) >> 4)) == 1L) {
      PrintPart_Appl_C(OutStream, (ATermAppl) Part, pp_format,
        false, 0);
    } else if (((unsigned int)((((Part)->header) & (((1 << 3)-1) << 4)) >> 4)) == 4L) {
      fprints_C(OutStream, "[");
      PrintPart_List_C(OutStream, (ATermList) Part,
        pp_format, false, 0, "", ", ");
      fprints_C(OutStream, "]");
    } else {

      gsErrorMsg("ATerm Part is not an ATermAppl or an ATermList\n");



      ((false) ? static_cast<void> (0) : __assert_fail ("false", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 492, __PRETTY_FUNCTION__));
    }
  }
}

void PrintPart_Appl_C(FILE* OutStream,
  const ATermAppl Part, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  if (gsIsString(Part)) {

    fprints_C(OutStream, (at_lookup_table[(((AFun)(((Part)->header) >> 34)))]->name));
  } else if (gsIsSortExpr(Part)) {

    dbg_prints_C("printing sort expression or unknown\n");
    PrintSortExpr_C(OutStream, Part, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsStructCons(Part)) {

    dbg_prints_C("printing structured sort constructor\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList StructProjs = ATLgetArgument(Part, 1);
    if (ATgetLength(StructProjs) > 0) {
      fprints_C(OutStream, "(");
      PrintPart_List_C(OutStream, StructProjs,
        pp_format, ShowSorts, PrecLevel, __null, ", ");
      fprints_C(OutStream, ")");
    }
    ATermAppl Recogniser = ATAgetArgument(Part, 2);
    if (!gsIsNil(Recogniser)) {
      fprints_C(OutStream, "?");
      PrintPart_Appl_C(OutStream, Recogniser,
        pp_format, ShowSorts, PrecLevel);
    }
  } else if (gsIsStructProj(Part)) {

    dbg_prints_C("printing structured sort projection\n");
    ATermAppl Projection = ATAgetArgument(Part, 0);
    if (!gsIsNil(Projection)) {
      PrintPart_Appl_C(OutStream, Projection,
        pp_format, ShowSorts, PrecLevel);
      fprints_C(OutStream, ": ");
    }
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 1),
      pp_format, ShowSorts, 0);
  } else if (gsIsNil(Part)) {

    dbg_prints_C("printing nil\n");
    fprints_C(OutStream, "nil");
  } else if (gsIsDataExpr(Part)) {

    dbg_prints_C("printing data expression\n");
    PrintDataExpr_C(OutStream, Part, pp_format, ShowSorts, PrecLevel);

  } else if (gsIsIdInit(Part)) {

    dbg_prints_C("printing identifier initialisation\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, " = ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 1),
      pp_format, ShowSorts, 0);
  } else if (gsIsMultAct(Part)) {

    dbg_prints_C("printing multiaction\n");
    ATermList Actions = ATLgetArgument(Part, 0);
    int ActionsLength = ATgetLength(Actions);
    if (ActionsLength == 0) {
      fprints_C(OutStream, "tau");
    } else {

      if (PrecLevel > 7) fprints_C(OutStream, "(");
      PrintPart_List_C(OutStream, Actions,
        pp_format, ShowSorts, PrecLevel, __null, "|");
      if (PrecLevel > 7) fprints_C(OutStream, ")");
    }
  } else if (gsIsActId(Part)) {

    dbg_prints_C("printing action identifier\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    if (ShowSorts) {
      ATermList SortExprs = ATLgetArgument(Part, 1);
      if (ATgetLength(SortExprs) > 0) {
        fprints_C(OutStream, ": ");
        PrintPart_List_C(OutStream, SortExprs,
          pp_format, ShowSorts, 2, __null, " # ");
      }
    }
  } else if (gsIsProcExpr(Part)) {

    dbg_prints_C("printing process expression\n");
    PrintProcExpr_C(OutStream, Part, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsProcVarId(Part)) {

    dbg_prints_C("printing process variable\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    if (ShowSorts) {
      ATermList SortExprs = ATLgetArgument(Part, 1);
      if (ATgetLength(SortExprs) > 0) {
        fprints_C(OutStream, ": ");
        PrintPart_List_C(OutStream, SortExprs,
          pp_format, ShowSorts, 2, __null, " # ");
      }
    }
  } else if (gsIsMultActName(Part)) {

    dbg_prints_C("printing multiaction name\n");
    PrintPart_List_C(OutStream, ATLgetArgument(Part, 0),
      pp_format, ShowSorts, 0, __null, " | ");
  } else if (gsIsRenameExpr(Part)) {

    dbg_prints_C("printing renaming expression\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, " -> ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 1),
      pp_format, ShowSorts, PrecLevel);
  } else if (gsIsCommExpr(Part)) {

    dbg_prints_C("printing communication expression\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermAppl CommResult = ATAgetArgument(Part, 1);
    if (!gsIsNil(CommResult)) {
      fprints_C(OutStream, " -> ");
      PrintPart_Appl_C(OutStream, CommResult,
        pp_format, ShowSorts, PrecLevel);
    }
  } else if (gsIsProcSpec(Part) || gsIsLinProcSpec(Part)) {

    dbg_prints_C("printing process specification or LPS\n");
    ATermAppl DataSpec = ATAgetArgument(Part, 0);
    bool DataSpecEmpty = ((ATbool)((ATerm)(DataSpec) == (ATerm)(gsMakeEmptyDataSpec())));
    ATermAppl ActSpec = ATAgetArgument(Part, 1);
    bool ActSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(ActSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(ActSpec, 0))->aterm.tail == __null));
    ATermAppl GlobVarSpec = ATAgetArgument(Part, 2);
    bool GlobVarSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(GlobVarSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(GlobVarSpec, 0))->aterm.tail == __null));
    ATermAppl ProcEqnSpec = ATAgetArgument(Part, 3);
    bool ProcEqnSpecEmpty = gsIsProcSpec(Part)?(bool)((ATbool)(((ATermList)ATLgetArgument(ProcEqnSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(ProcEqnSpec, 0))->aterm.tail == __null)):false;
    ATermAppl ProcInit = ATAgetArgument(Part, 4);
    PrintPart_Appl_C(OutStream, DataSpec, pp_format, ShowSorts, PrecLevel);
    if (!ActSpecEmpty && !DataSpecEmpty) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, ActSpec, pp_format, ShowSorts, PrecLevel);
    if (!GlobVarSpecEmpty && (!DataSpecEmpty || !ActSpecEmpty)) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, GlobVarSpec, pp_format, ShowSorts, PrecLevel);
    if (!ProcEqnSpecEmpty && (!DataSpecEmpty || !ActSpecEmpty || !GlobVarSpecEmpty)) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, ProcEqnSpec, pp_format, ShowSorts, PrecLevel);
    if (!DataSpecEmpty || !ActSpecEmpty || !GlobVarSpecEmpty || !ProcEqnSpecEmpty) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, ProcInit, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsDataSpec(Part)) {

    dbg_prints_C("printing data specification\n");
    ATermAppl SortSpec = ATAgetArgument(Part, 0);
    bool SortSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(SortSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(SortSpec, 0))->aterm.tail == __null));
    ATermAppl ConsSpec = ATAgetArgument(Part, 1);
    bool ConsSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(ConsSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(ConsSpec, 0))->aterm.tail == __null));
    ATermAppl MapSpec = ATAgetArgument(Part, 2);
    bool MapSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(MapSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(MapSpec, 0))->aterm.tail == __null));
    ATermAppl DataEqnSpec = ATAgetArgument(Part, 3);
    bool DataEqnSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(DataEqnSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(DataEqnSpec, 0))->aterm.tail == __null));
    PrintPart_Appl_C(OutStream, SortSpec, pp_format, ShowSorts, PrecLevel);
    if (!ConsSpecEmpty && !SortSpecEmpty) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, ConsSpec, pp_format, ShowSorts, PrecLevel);
    if (!MapSpecEmpty && (!SortSpecEmpty || !ConsSpecEmpty)) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, MapSpec, pp_format, ShowSorts, PrecLevel);
    if (!DataEqnSpecEmpty && (!SortSpecEmpty || !ConsSpecEmpty || !MapSpecEmpty)) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, DataEqnSpec, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsSortSpec(Part)) {

    dbg_prints_C("printing sort specification\n");
    ATermList SortDecls = ATLgetArgument(Part, 0);
    if (ATgetLength(SortDecls) > 0) {
      fprints_C(OutStream, "sort ");
      PrintPart_List_C(OutStream, SortDecls,
        pp_format, ShowSorts, PrecLevel, ";\n", "     ");
    }
  } else if (gsIsConsSpec(Part) || gsIsMapSpec(Part)) {

    dbg_prints_C("printing operation specification\n");
    ATermList OpIds = ATLgetArgument(Part, 0);
    if (ATgetLength(OpIds) > 0) {
      fprints_C(OutStream, gsIsConsSpec(Part)?"cons ":"map  ");
      PrintDecls_C(OutStream, OpIds, pp_format, ";\n", "     ");
    }
  } else if (gsIsDataEqnSpec(Part)) {

    dbg_prints_C("printing equation specification\n");
    PrintEqns_C(OutStream, ATLgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
  } else if (gsIsActSpec(Part)) {

    dbg_prints_C("printing action specification\n");
    ATermList ActIds = ATLgetArgument(Part, 0);
    if (ATgetLength(ActIds) > 0) {
      fprints_C(OutStream, "act  ");
      PrintDecls_C(OutStream, ActIds, pp_format, ";\n", "     ");
    }
  } else if (gsIsSortRef(Part)) {

    dbg_prints_C("printing sort reference declaration\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, " = ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 1),
      pp_format, ShowSorts, PrecLevel);
  } else if (gsIsDataEqn(Part)) {

    dbg_prints_C("printing data equation\n");
    ATermAppl Condition = ATAgetArgument(Part, 1);
    if ( !data::sort_bool::is_true_function_symbol(data::data_expression(Condition))) {
      PrintPart_Appl_C(OutStream, Condition,
        pp_format, ShowSorts, 0);
      fprints_C(OutStream, "  ->  ");
    }
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 2),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, "  =  ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 3),
      pp_format, ShowSorts, 0);
  } else if (gsIsGlobVarSpec(Part)) {

    dbg_prints_C("printing global variable specification\n");
    ATermList Vars = ATLgetArgument(Part, 0);
    if (ATgetLength(Vars) > 0) {
      fprints_C(OutStream, "glob ");
      PrintDecls_C(OutStream, (pp_format == ppDebug)?Vars:gsGroupDeclsBySort(Vars),
        pp_format, ";\n", "     ");
    }
  } else if (gsIsProcEqnSpec(Part)) {

    dbg_prints_C("printing process equation specification\n");
    ATermList ProcEqns = ATLgetArgument(Part, 0);
    if (ATgetLength(ProcEqns) > 0) {
      fprints_C(OutStream, "proc ");
      PrintPart_List_C(OutStream, ProcEqns,
        pp_format, ShowSorts, PrecLevel, ";\n", "     ");
    }
  } else if (gsIsLinearProcess(Part)) {

    dbg_prints_C("printing linear process\n");

    ATermList VarDecls = ATLgetArgument(Part, 0);
    int VarDeclsLength = ATgetLength(VarDecls);
    fprints_C(OutStream, "proc P");
    if (VarDeclsLength > 0) {
      fprints_C(OutStream, "(");
      PrintDecls_C(OutStream, VarDecls, pp_format, __null, ", ");
      fprints_C(OutStream, ")");
    }
    fprints_C(OutStream, " =");

    ATermList Summands = ATLgetArgument(Part, 1);
    int SummandsLength = ATgetLength(Summands);
    if (SummandsLength == 0) {
      fprints_C(OutStream, " delta@0;\n");
    } else {

      fprints_C(OutStream, "\n       ");
      ATermList l = Summands;
      while (!((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null))) {
        if (!((ATbool)((ATerm)(l) == (ATerm)(Summands)))) {
          fprints_C(OutStream, "\n     + ");
        }
        PrintLinearProcessSummand_C(OutStream, ATAgetFirst(l),
          pp_format, ShowSorts);
        l = (((ATermList)l)->aterm.tail);
      }
      fprints_C(OutStream, ";\n");
    }
  } else if (gsIsProcEqn(Part)) {

    dbg_prints_C("printing process equation\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList DataVarIds = ATLgetArgument(Part, 1);
    if (ATgetLength(DataVarIds) > 0) {
      fprints_C(OutStream, "(");
      PrintDecls_C(OutStream, DataVarIds, pp_format, __null, ", ");
      fprints_C(OutStream, ")");
    }
    fprints_C(OutStream, " = ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 2),
      pp_format, ShowSorts, 0);
  } else if (gsIsLinearProcessSummand(Part)) {

    PrintLinearProcessSummand_C(OutStream, Part, pp_format, ShowSorts);
  } else if (gsIsProcessInit(Part)) {

    dbg_prints_C("printing initialisation\n");
    fprints_C(OutStream, "init ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, ";\n");
  } else if (gsIsLinearProcessInit(Part)) {

    dbg_prints_C("printing LPS initialisation\n");
    fprints_C(OutStream, "init P");
    ATermList Args = ATLgetArgument(Part, 0);
    if (ATgetLength(Args) > 0) {
      fprints_C(OutStream, "(");
      if (pp_format == ppDefault) {
        Args = GetAssignmentsRHS(Args);
      }
      PrintPart_List_C(OutStream, Args,
        pp_format, ShowSorts, 0, __null, ", ");
      fprints_C(OutStream, ")");
    }
    fprints_C(OutStream, ";\n");
  } else if (gsIsStateFrm(Part)) {

    dbg_prints_C("printing state formula\n");
    PrintStateFrm_C(OutStream, Part, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsDataVarIdInit(Part)) {

    dbg_prints_C("printing data variable identifier and initialisation\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, " = ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 1),
      pp_format, ShowSorts, 0);
  } else if (gsIsRegFrm(Part)) {

    dbg_prints_C("printing regular formula\n");
    PrintRegFrm_C(OutStream, Part, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsPBES(Part)) {

    dbg_prints_C("printing PBES specification\n");
    ATermAppl DataSpec = ATAgetArgument(Part, 0);
    bool DataSpecEmpty = ((ATbool)((ATerm)(DataSpec) == (ATerm)(gsMakeEmptyDataSpec())));
    ATermAppl GlobVarSpec = ATAgetArgument(Part, 1);
    bool GlobVarSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(GlobVarSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(GlobVarSpec, 0))->aterm.tail == __null));
    ATermAppl PBEqnSpec = ATAgetArgument(Part, 2);
    bool PBEqnSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(PBEqnSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(PBEqnSpec, 0))->aterm.tail == __null));
    ATermAppl PBInit = ATAgetArgument(Part, 3);
    PrintPart_Appl_C(OutStream, DataSpec, pp_format, ShowSorts, PrecLevel);
    if (!GlobVarSpecEmpty && !DataSpecEmpty) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, GlobVarSpec, pp_format, ShowSorts, PrecLevel);
    if (!PBEqnSpecEmpty && (!DataSpecEmpty || !GlobVarSpecEmpty)) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, PBEqnSpec, pp_format, ShowSorts, PrecLevel);
    if (!DataSpecEmpty || !GlobVarSpecEmpty || !PBEqnSpecEmpty) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, PBInit, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsPBEqnSpec(Part)) {

    dbg_prints_C("printing parameterised boolean equation specification\n");
    ATermList PBEqns = ATLgetArgument(Part, 0);
    if (ATgetLength(PBEqns) > 0) {
      fprints_C(OutStream, "pbes ");
      PrintPart_List_C(OutStream, PBEqns,
        pp_format, ShowSorts, PrecLevel, ";\n", "     ");
    }
  } else if (gsIsPBInit(Part)) {

    dbg_prints_C("printing parameterised boolean initialisation\n");
    fprints_C(OutStream, "init ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, ";\n");
  } else if (gsIsPBEqn(Part)) {

    dbg_prints_C("printing parameterised boolean equation\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, " ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 1),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, " =\n       ");
    PrintPBExpr_C(OutStream, ATAgetArgument(Part, 2),
      pp_format, ShowSorts, PrecLevel);
  } else if (gsIsFixpoint(Part)) {

    dbg_prints_C("printing fixpoint\n");
    if (gsIsNu(Part)) {
      fprints_C(OutStream, "nu");
    } else {
      fprints_C(OutStream, "mu");
    }
  } else if (gsIsPropVarDecl(Part)) {

    dbg_prints_C("printing propositional variable declaration\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList DataVarIds = ATLgetArgument(Part, 1);
    if (ATgetLength(DataVarIds) > 0) {
      fprints_C(OutStream, "(");
      PrintDecls_C(OutStream, DataVarIds, pp_format, __null, ", ");
      fprints_C(OutStream, ")");
    }
  } else if (gsIsPBExpr(Part)) {

    dbg_prints_C("printing parameterised boolean expression\n");
    PrintPBExpr_C(OutStream, Part, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsActionRenameSpec(Part)) {

    dbg_prints_C("printing action rename specification\n");
    ATermAppl DataSpec = ATAgetArgument(Part, 0);
    bool DataSpecEmpty = ((ATbool)((ATerm)(DataSpec) == (ATerm)(gsMakeEmptyDataSpec())));
    ATermAppl ActSpec = ATAgetArgument(Part, 1);
    bool ActSpecEmpty = ((ATbool)(((ATermList)ATLgetArgument(ActSpec, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(ActSpec, 0))->aterm.tail == __null));
    ATermAppl ActionRenameRules = ATAgetArgument(Part, 2);
    bool ActionRenameRulesEmpty = ((ATbool)(((ATermList)ATLgetArgument(ActionRenameRules, 0))->aterm.head == __null && ((ATermList)ATLgetArgument(ActionRenameRules, 0))->aterm.tail == __null));
    PrintPart_Appl_C(OutStream, DataSpec, pp_format, ShowSorts, PrecLevel);
    if (!ActSpecEmpty && !DataSpecEmpty) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, ActSpec, pp_format, ShowSorts, PrecLevel);
    if (!ActionRenameRulesEmpty && (!DataSpecEmpty || !ActSpecEmpty)) {
      fprints_C(OutStream, "\n");
    }
    PrintPart_Appl_C(OutStream, ActionRenameRules, pp_format, ShowSorts, PrecLevel);
  } else if (gsIsActionRenameRule(Part)) {

    dbg_prints_C("printing action rename rule\n");
    ATermAppl Condition = ATAgetArgument(Part, 1);
    if ( !data::sort_bool::is_true_function_symbol(data::data_expression(Condition))) {
      PrintPart_Appl_C(OutStream, Condition,
        pp_format, ShowSorts, 0);
      fprints_C(OutStream, "  ->  ");
    }
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 2),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, "  =>  ");
    PrintPart_Appl_C(OutStream, ATAgetArgument(Part, 3),
      pp_format, ShowSorts, 0);
  } else if (gsIsActionRenameRules(Part)) {

    dbg_prints_C("printing action rename rules\n");
    PrintEqns_C(OutStream, ATLgetArgument(Part, 0),
      pp_format, ShowSorts, PrecLevel);
  } else {

    gsErrorMsg("the term %T is not part of the internal format\n", Part);






    ((false) ? static_cast<void> (0) : __assert_fail ("false", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 950, __PRETTY_FUNCTION__));
  }
}

void PrintPart_List_C(FILE* OutStream,
  const ATermList Parts, t_pp_format pp_format, bool ShowSorts, int PrecLevel,
  const char *Terminator, const char *Separator)
{
  ATermList l = Parts;
  while (!((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null))) {
    if (!((ATbool)((ATerm)(l) == (ATerm)(Parts))) && Separator != __null) {
      fprints_C(OutStream, Separator);
    }
    PrintPart_Appl_C(OutStream, ATAgetFirst(l),
      pp_format, ShowSorts, PrecLevel);
    if (Terminator != __null) {
      fprints_C(OutStream, Terminator);
    }
    l = (((ATermList)l)->aterm.tail);
  }
}

void PrintPart_BagEnum_C(FILE* OutStream,
  const ATermList Parts, t_pp_format pp_format, bool ShowSorts, int PrecLevel,
  const char *Terminator, const char *Separator)
{
  ATermList l = Parts;
  while (!((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null))) {
    if (!((ATbool)((ATerm)(l) == (ATerm)(Parts))) && Separator != __null) {
      fprints_C(OutStream, Separator);
    }
    PrintPart_Appl_C(OutStream, ATAgetFirst(l),
      pp_format, ShowSorts, PrecLevel);
    l = (((ATermList)l)->aterm.tail);
    fprints_C(OutStream, ": ");
    PrintPart_Appl_C(OutStream, ATAgetFirst(l),
      pp_format, ShowSorts, PrecLevel);
    if (Terminator != __null) {
      fprints_C(OutStream, Terminator);
    }
    l = (((ATermList)l)->aterm.tail);
  }
}

void PrintEqns_C(FILE* OutStream, const ATermList Eqns,
  t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  if (pp_format == ppDebug) {
    ATermList l = Eqns;
    while (!((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null))) {
      ATermAppl Eqn = ATAgetFirst(l);
      ATermList DataDecls = ATLgetArgument(Eqn, 0);
      if (!((ATbool)(((ATermList)DataDecls)->aterm.head == __null && ((ATermList)DataDecls)->aterm.tail == __null))) {
        fprints_C(OutStream, "var  ");
        PrintDecls_C(OutStream, (pp_format == ppDebug)?DataDecls:gsGroupDeclsBySort(DataDecls),
          pp_format, ";\n", "     ");
      }
      if (gsIsDataEqn(Eqn)) {
        fprints_C(OutStream, "eqn  ");
      } else if (gsIsActionRenameRule(Eqn)) {
        fprints_C(OutStream, "rename\n     ");
      } else {
        ((false) ? static_cast<void> (0) : __assert_fail ("false", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1012, __PRETTY_FUNCTION__));
      }
      PrintPart_Appl_C(OutStream, Eqn,
        pp_format, ShowSorts, PrecLevel);
      fprints_C(OutStream, ";\n");
      l = (((ATermList)l)->aterm.tail);
      if (!((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null))) {
        fprints_C(OutStream, "\n");
      }
    }
  } else {
    int EqnsLength = ATgetLength(Eqns);
    if (EqnsLength > 0) {
      int StartPrefix = 0;
      ATermTable VarDeclTable = ATtableCreate(63, 50);




      int i = 0;
      while (i < EqnsLength) {






        ATermAppl Eqn = ATAelementAt(Eqns, i);
        bool Consistent = gsHasConsistentContext(VarDeclTable, Eqn);
        if (Consistent) {

          ATermList VarDecls = ATLgetArgument(Eqn, 0);
          int VarDeclsLength = ATgetLength(VarDecls);
          for (int j = 0; j < VarDeclsLength; j++) {
            ATermAppl VarDecl = ATAelementAt(VarDecls, j);
            ATermAppl VarDeclName = ATAgetArgument(VarDecl, 0);
            if (ATtableGet(VarDeclTable, (ATerm) VarDeclName) == __null) {
              ATtablePut(VarDeclTable, (ATerm) VarDeclName, (ATerm) VarDecl);
            }
          }
          i++;
        }
        if (!Consistent || (i == EqnsLength)) {




          ATermList VarDecls = ATtableValues(VarDeclTable);
          if (ATgetLength(VarDecls) > 0) {
            fprints_C(OutStream, "var  ");
            PrintDecls_C(OutStream, (pp_format == ppDebug)?VarDecls:gsGroupDeclsBySort(VarDecls),
              pp_format, ";\n", "     ");
          }
          if (gsIsDataEqn(Eqn)) {
            fprints_C(OutStream, "eqn  ");
          } else if (gsIsActionRenameRule(Eqn)) {
            fprints_C(OutStream, "rename\n     ");
          } else {
            ((false) ? static_cast<void> (0) : __assert_fail ("false", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1070, __PRETTY_FUNCTION__));
          }
          PrintPart_List_C(OutStream, ATgetSlice(Eqns, StartPrefix, i),
             pp_format, ShowSorts, PrecLevel, ";\n", "     ");
          if (i < EqnsLength) {
            fprints_C(OutStream, "\n");
            StartPrefix = i;
            ATtableReset(VarDeclTable);
          }
        }
      }

      ATtableDestroy(VarDeclTable);
    }
  }
}

void PrintDecls_C(FILE* OutStream, const ATermList Decls,
  t_pp_format pp_format, const char *Terminator, const char *Separator)
{
  if (!((ATbool)(((ATermList)Decls)->aterm.head == __null && ((ATermList)Decls)->aterm.tail == __null))) {
    ATermAppl Decl = ATAgetFirst(Decls);
    ATermList NextDecls = (((ATermList)Decls)->aterm.tail);
    while (!((ATbool)(((ATermList)NextDecls)->aterm.head == __null && ((ATermList)NextDecls)->aterm.tail == __null)))
    {
      if (((ATbool)((ATerm)((((ATermAppl)Decl)->aterm.arg[1])) == (ATerm)((((ATermAppl)ATAgetFirst(NextDecls))->aterm.arg[1]))))) {

        PrintDecl_C(OutStream, Decl, pp_format, false);
        fprints_C(OutStream, ",");
      } else {
        PrintDecl_C(OutStream, Decl, pp_format, true);
        if (Terminator != __null) fprints_C(OutStream, Terminator);
        if (Separator != __null) fprints_C(OutStream, Separator);
      }
      Decl = ATAgetFirst(NextDecls);
      NextDecls = (((ATermList)NextDecls)->aterm.tail);
    }
    PrintDecl_C(OutStream, Decl, pp_format, true);
    if (Terminator != __null) fprints_C(OutStream, Terminator);
  }
}

void PrintDecl_C(FILE* OutStream, const ATermAppl Decl,
  t_pp_format pp_format, const bool ShowSorts)
{
  PrintPart_Appl_C(OutStream, ATAgetArgument(Decl, 0),
    pp_format, ShowSorts, 0);
  if (ShowSorts) {
    if (gsIsActId(Decl)) {
      ATermList SortExprs = ATLgetArgument(Decl, 1);
      if (ATgetLength(SortExprs) > 0) {
        fprints_C(OutStream, ": ");
        PrintPart_List_C(OutStream, SortExprs,
          pp_format, ShowSorts, 2, __null, " # ");
      }
    } else {
      fprints_C(OutStream, ": ");
      PrintPart_Appl_C(OutStream, ATAgetArgument(Decl, 1),
        pp_format, ShowSorts, 0);
    }
  }
}

static void PrintSortExpr_C(FILE* OutStream,
  const ATermAppl SortExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsSortExpr(SortExpr)) ? static_cast<void> (0) : __assert_fail ("gsIsSortExpr(SortExpr)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1136, __PRETTY_FUNCTION__));
  if (gsIsSortId(SortExpr)) {

    dbg_prints_C("printing standard sort identifier\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(SortExpr, 0),
      pp_format, ShowSorts, PrecLevel);
  } else if (gsIsSortArrow(SortExpr)) {

    dbg_prints_C("printing product arrow sort\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    PrintPart_List_C(OutStream, ATLgetArgument(SortExpr, 0),
      pp_format, ShowSorts, 1, __null, " # ");
    fprints_C(OutStream, " -> ");
    PrintSortExpr_C(OutStream, ATAgetArgument(SortExpr, 1),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (data::sort_list::is_list(data::sort_expression(SortExpr))) {

    dbg_prints_C("printing list sort\n");
    fprints_C(OutStream, "List(");
    PrintSortExpr_C(OutStream, ATAgetArgument(SortExpr, 1),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  } else if (data::sort_set::is_set(data::sort_expression(SortExpr))) {

    dbg_prints_C("printing set sort\n");
    fprints_C(OutStream, "Set(");
    PrintSortExpr_C(OutStream, ATAgetArgument(SortExpr, 1),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  } else if (data::sort_bag::is_bag(data::sort_expression(SortExpr))) {

    dbg_prints_C("printing bag sort\n");
    fprints_C(OutStream, "Bag(");
    PrintSortExpr_C(OutStream, ATAgetArgument(SortExpr, 1),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  } else if (gsIsSortStruct(SortExpr)) {

    dbg_prints_C("printing structured sort\n");
    if (PrecLevel > 1) fprints_C(OutStream, "(");
    fprints_C(OutStream, "struct ");
    PrintPart_List_C(OutStream, ATLgetArgument(SortExpr, 0),
      pp_format, ShowSorts, PrecLevel, __null, " | ");
    if (PrecLevel > 1) fprints_C(OutStream, ")");
  } else if (gsIsSortUnknown(SortExpr)) {

    dbg_prints_C("printing unknown\n");
    fprints_C(OutStream, "unknown");
  } else if (gsIsSortsPossible(SortExpr)) {

    dbg_prints_C("printing possible sorts\n");
    fprints_C(OutStream, "{");
    PrintPart_List_C(OutStream, ATLgetArgument(SortExpr, 0),
      pp_format, ShowSorts, 0, __null, ", ");
    fprints_C(OutStream, "}");
  }
}

static
ATermAppl gsGetDataExprHead(ATermAppl DataExpr)
{
  while (gsIsDataAppl(DataExpr)) {
   DataExpr = ATAgetArgument(DataExpr, 0);
  }
  return DataExpr;
}

static
ATermList gsGetDataExprArgs(ATermAppl DataExpr)
{
  ATermList l = (ATempty);
  while (gsIsDataAppl(DataExpr)) {
    l = ATconcat(ATLgetArgument(DataExpr, 1), l);
    DataExpr = ATAgetArgument(DataExpr, 0);
  }
  return l;
}


static ATermAppl reconstruct_pos_mult(const ATermAppl PosExpr, std::vector<char>& Mult)
{
  ATermAppl Head = gsGetDataExprHead(PosExpr);
  ATermList Args = gsGetDataExprArgs(PosExpr);
  if (data::sort_pos::is_c1_function_symbol(data::data_expression(PosExpr))) {

    return data::function_symbol(data::detail::vector_number_to_string(Mult), data::sort_pos::pos());
  } else if (data::sort_pos::is_cdub_function_symbol(data::data_expression(Head))) {

    ATermAppl BoolArg = ATAelementAt(Args, 0);
    ATermAppl PosArg = ATAelementAt(Args, 1);
    data::detail::decimal_number_multiply_by_two(Mult);
    PosArg = reconstruct_pos_mult(data::data_expression(PosArg), Mult);
    if (data::sort_bool::is_false_function_symbol(data::data_expression(BoolArg))) {

      return PosArg;
    } else if (data::sort_bool::is_true_function_symbol(data::data_expression(BoolArg))) {

      return data::sort_real::plus(data::data_expression(data::data_expression(PosArg)),
                                  data::function_symbol(data::detail::vector_number_to_string(Mult), data::sort_pos::pos()));
    } else if (data::detail::vector_number_to_string(Mult) == "1") {

      return data::sort_real::plus(data::data_expression(PosArg), bool_to_numeric(data::data_expression(BoolArg), data::sort_nat::nat()));
    } else {

      return data::sort_real::plus(data::data_expression(PosArg),
                                  data::sort_real::times(data::function_symbol(data::detail::vector_number_to_string(Mult), data::sort_nat::nat()),
                                                        bool_to_numeric(data::data_expression(BoolArg), data::sort_nat::nat())));
    }
  } else {

    if (data::detail::vector_number_to_string(Mult) == "1") {
      return PosExpr;
    } else {
      return data::sort_real::times(data::function_symbol(data::detail::vector_number_to_string(Mult), data::sort_pos::pos()), data::data_expression(PosExpr));
    }
  }
}

static ATermAppl reconstruct_numeric_expression(ATermAppl Part) {
  if (data::sort_pos::is_c1_function_symbol(data::data_expression(Part)) || data::sort_pos::is_cdub_application(data::data_expression(Part))) {

    if (data::sort_pos::is_positive_constant(data::data_expression(Part))) {
      std::string positive_value(data::sort_pos::positive_constant_as_string(data::data_expression(Part)));
      Part = data::function_symbol(positive_value, data::sort_pos::pos());
    } else {
      std::vector< char > number = data::detail::string_to_vector_number("1");
      Part = reconstruct_pos_mult(Part, number);
    }
  } else if (data::sort_nat::is_c0_function_symbol(data::data_expression(Part))) {

    Part = data::function_symbol("0", data::sort_nat::nat());
  } else if ((data::sort_nat::is_cnat_application(data::data_expression(Part)) || data::sort_nat::is_pos2nat_application(data::data_expression(Part)))
            && (data::sort_pos::is_pos(data::data_expression(ATAgetFirst(ATLgetArgument(Part, 1))).sort()))) {

    ATermAppl value = ATAgetFirst(ATLgetArgument(Part, 1));
    value = reconstruct_numeric_expression(value);
    Part = data::sort_nat::pos2nat(data::data_expression(value));
    if (gsIsOpId(value)) {
      ATermAppl name = ATAgetArgument(value, 0);
      if (gsIsNumericString(gsATermAppl2String(name))) {
        Part = data::function_symbol(name, data::sort_nat::nat());
      }
    }
  } else if (data::sort_nat::is_cpair_application(data::data_expression(Part))) {

  } else if (data::sort_int::is_cneg_application(data::data_expression(Part))) {

    Part = data::sort_int::negate(data::data_expression(ATAgetFirst(ATLgetArgument(Part, 1))));
  } else if ((data::sort_int::is_cint_application(data::data_expression(Part)) || data::sort_int::is_nat2int_application(data::data_expression(Part)))
            && (data::sort_nat::is_nat(data::data_expression(ATAgetFirst(ATLgetArgument(Part, 1))).sort()))) {

    ATermAppl value = ATAgetFirst(ATLgetArgument(Part, 1));
    value = reconstruct_numeric_expression(value);
    Part = data::sort_int::nat2int(data::data_expression(value));
    if (gsIsOpId(value)) {
      ATermAppl name = ATAgetArgument(value, 0);
      if (gsIsNumericString(gsATermAppl2String(name))) {
        Part = data::function_symbol(name, data::sort_int::int_());
      }
    }
  } else if (data::sort_real::is_int2real_application(data::data_expression(Part))
            && (data::sort_int::is_int(data::data_expression(ATAgetFirst(ATLgetArgument(Part, 1))).sort()))) {

    ATermAppl value = ATAgetFirst(ATLgetArgument(Part, 1));
    value = reconstruct_numeric_expression(value);
    Part = data::sort_real::int2real(data::data_expression(value));
    if (gsIsOpId(value)) {
      ATermAppl name = ATAgetArgument(value, 0);
      if (gsIsNumericString(gsATermAppl2String(name))) {
        Part = data::function_symbol(name, data::sort_real::real_());
      }
    }
  } else if (data::sort_real::is_creal_application(data::data_expression(Part))) {

    ATermList Args = ATLgetArgument(Part, 1);
    ATermAppl ArgNumerator = reconstruct_numeric_expression(ATAelementAt(Args, 0));
    ATermAppl ArgDenominator = reconstruct_numeric_expression(ATAelementAt(Args, 1));
    if (((ATbool)((ATerm)(ArgDenominator) == (ATerm)(static_cast<ATermAppl>(data::function_symbol("1", data::sort_pos::pos())))))) {
      Part = data::sort_real::int2real(data::data_expression(ArgNumerator));
      if (gsIsOpId(ArgNumerator)) {
        ATermAppl name = ATAgetArgument(ArgNumerator, 0);
        if (gsIsNumericString(gsATermAppl2String(name))) {
          Part = data::function_symbol(name, data::sort_real::real_());
        }
      }
    } else {
      Part = data::sort_real::divides(data::data_expression(ArgNumerator),
                                      data::sort_int::pos2int(data::data_expression(ArgDenominator)));
      if (gsIsOpId(ArgDenominator)) {
        ATermAppl name = ATAgetArgument(ArgDenominator, 0);
        if (gsIsNumericString(gsATermAppl2String(name))) {
          Part = data::sort_real::divides(data::data_expression(ArgNumerator),
                                          data::function_symbol(name, data::sort_int::int_()));
        }
      }
    }
  }

  return Part;
}

static ATermAppl
reconstruct_container_expression(ATermAppl Part)
{
  using namespace mcrl2::data;
  using namespace mcrl2::data::sort_list;
  using namespace mcrl2::data::sort_set;
  using namespace mcrl2::data::sort_fset;
  using namespace mcrl2::data::sort_bag;

  if(!gsIsDataAppl(Part) && !gsIsOpId(Part))
  {
    return Part;
  }

  data_expression expr(Part);
  if(is_cons_application(expr))
  {
    data_expression_vector elements;
    while(is_cons_application(expr))
    {
      elements.push_back(sort_list::head(expr));
      expr = sort_list::tail(expr);
    }

    if(is_nil_function_symbol(expr))
    {
      Part = list_enumeration(expr.sort(), elements);
    }
  }
  else if (is_snoc_application(expr))
  {
    data_expression_vector elements;
    while(is_snoc_application(expr))
    {
      elements.insert(elements.begin(), sort_list::rhead(expr));
      expr = sort_list::rtail(expr);
    }

    if(is_nil_function_symbol(expr))
    {
      Part = list_enumeration(expr.sort(), elements);
    }
  }
  else if (is_setconstructor_application(expr))
  {



    sort_expression element_sort = *function_sort(sort_set::left(expr).sort()).domain().begin();
    if (is_false_function_function_symbol(sort_set::left(expr)))
    {
      Part = reconstruct_container_expression(static_cast<ATermAppl>(setfset(element_sort, sort_set::right(expr))));
    }
    else if (is_true_function_function_symbol(sort_set::right(expr)))
    {
      Part = static_cast<ATermAppl>(setcomplement(setfset(element_sort, sort_set::right(expr))));
    }
    else
    {
      ATermAppl se_func = sort_set::left(expr).sort();
      ATermAppl se_func_dom = ATAgetFirst(ATLgetArgument(se_func, 0));
      ATermAppl var = gsMakeDataVarId(gsFreshString2ATermAppl("x",
          (ATerm) static_cast<ATermAppl>(expr), true), se_func_dom);
      ATermAppl body;
      if (data::sort_fset::is_fset_empty_function_symbol(sort_set::right(expr)))
      {
        body = sort_set::left(expr)(data::variable(var));
      }
      else
      {
        data_expression lhs(sort_set::left(expr)(data::variable(var)));
        data_expression rhs(setin(element_sort, data_expression(var), setfset(element_sort, sort_set::right(expr))));
        body = static_cast<ATermAppl>(data::not_equal_to(lhs,rhs));
      }
      Part = gsMakeBinder(gsMakeSetComp(), ATmakeList1((ATerm) var), body);
    }
  }
  else if (sort_set::is_setfset_application(expr))
  {


    data_expression de_fset(sort_set::arg(expr));
    data_expression result(reconstruct_container_expression(de_fset));
    if(sort_set::is_set_enumeration_application(result) || sort_set::is_set_enumeration_function_symbol(result))
    {
      Part = static_cast<ATermAppl>(result);
    }
  }
  else if (sort_fset::is_fset_empty_function_symbol(expr))
  {
    Part = static_cast<ATermAppl>(sort_set::set_enumeration(container_sort(expr.sort()).element_sort(), data_expression_vector()));
  }
  else if (sort_fset::is_fset_cons_application(expr) || sort_fset::is_fsetinsert_application(expr))
  {
    data_expression de_fset(expr);
    bool elts_is_consistent = true;
    data_expression_vector elements;
    while (!sort_fset::is_fset_empty_function_symbol(de_fset) && elts_is_consistent)
    {
      if (sort_fset::is_fset_cons_application(de_fset))
      {
        elements.push_back(sort_fset::head(de_fset));
        de_fset = sort_fset::tail(de_fset);
      }
      else if (sort_fset::is_fsetinsert_application(de_fset))
      {
        elements.push_back(sort_fset::left(de_fset));
        de_fset = sort_fset::right(de_fset);
      }
      else
      {
        elts_is_consistent = false;
      }
    }
    if (elts_is_consistent)
    {
      Part = static_cast<ATermAppl>(sort_set::set_enumeration(expr.sort(), elements));
    }
  }
  else if (sort_set::is_setcomprehension_application(expr))
  {

    data_expression body(sort_set::arg(expr));
    data_expression_vector variables;
    sort_expression_list domain_of_body_sort(function_sort(body.sort()).domain());
    data_expression_list context = atermpp::make_list(body);

    for(sort_expression_list::const_iterator i = domain_of_body_sort.begin();
        i != domain_of_body_sort.end(); ++i)
    {
      variable var = data::variable(gsMakeDataVarId(gsFreshString2ATermAppl("x",
          (ATerm) static_cast<ATermList>(context), true), static_cast<ATermAppl>(*i)));
      context = atermpp::push_front(context, data_expression(var));
      variables.push_back(var);
    }

    body = data::application(body, variables);
    Part = gsMakeBinder(gsMakeSetComp(), atermpp::convert<data_expression_list>(variables), body);
  }

  else if (sort_bag::is_bagconstructor_application(expr))
  {



    sort_expression element_sort = *function_sort(sort_bag::left(expr).sort()).domain().begin();
    if (is_zero_function_function_symbol(sort_bag::left(expr)))
    {
      Part = reconstruct_container_expression(static_cast<ATermAppl>(bagfbag(element_sort, sort_bag::right(expr))));
    }
    else
    {
      ATermAppl se_func = sort_bag::left(expr).sort();
      ATermAppl se_func_dom = ATAgetFirst(ATLgetArgument(se_func, 0));
      data_expression var(gsMakeDataVarId(gsFreshString2ATermAppl("x",
          (ATerm) static_cast<ATermAppl>(expr), true), se_func_dom));
      data_expression body;

      if (sort_bag::is_one_function_function_symbol(sort_bag::left(expr)))
      {
        body = number(sort_nat::nat(), "1");
      }
      else
      {
        body = sort_bag::left(expr)(var);
      }
      if(!sort_fbag::is_fbag_empty_function_symbol(sort_bag::right(expr)))
      {
        body = sort_nat::swap_zero(body, sort_bag::bagcount(element_sort, var, sort_bag::bagfbag(element_sort, sort_bag::right(expr))));
      }
      Part = gsMakeBinder(gsMakeBagComp(), make_list(var), body);
    }
  }
  else if (sort_bag::is_bagfbag_application(expr))
  {


    data_expression de_fbag(sort_bag::arg(expr));
    data_expression result(reconstruct_container_expression(de_fbag));
    if(sort_bag::is_bag_enumeration_application(result) || sort_bag::is_bag_enumeration_function_symbol(result))
    {
      Part = static_cast<ATermAppl>(result);
    }
  }
  else if (sort_fbag::is_fbag_empty_function_symbol(expr))
  {
    Part = static_cast<ATermAppl>(sort_bag::bag_enumeration(container_sort(expr.sort()).element_sort(), data_expression_vector()));
  }
  else if (sort_fbag::is_fbag_cons_application(expr) || sort_fbag::is_fbaginsert_application(expr) || sort_fbag::is_fbagcinsert_application(expr))
  {
    data_expression de_fbag(expr);
    bool elts_is_consistent = true;
    data_expression_vector elements;
    while (!sort_fbag::is_fbag_empty_function_symbol(de_fbag) && elts_is_consistent)
    {
      if (sort_fbag::is_fbag_cons_application(de_fbag))
      {
        elements.push_back(sort_fbag::head(de_fbag));
        elements.push_back(sort_fbag::headcount(de_fbag));
        de_fbag = sort_fbag::tail(de_fbag);
      }
      else if (sort_fbag::is_fbaginsert_application(de_fbag))
      {
        elements.push_back(sort_fbag::arg1(de_fbag));
        elements.push_back(sort_nat::cnat(sort_fbag::arg2(de_fbag)));
        de_fbag = sort_fbag::arg3(de_fbag);
      }
      else if (sort_fbag::is_fbagcinsert_application(de_fbag))
      {
        elements.push_back(sort_fbag::arg1(de_fbag));
        elements.push_back(sort_fbag::arg2(de_fbag));
        de_fbag = sort_fbag::arg3(de_fbag);
      }
      else
      {
        elts_is_consistent = false;
      }
    }
    if (elts_is_consistent)
    {
      Part = static_cast<ATermAppl>(sort_bag::bag_enumeration(container_sort(expr.sort()).element_sort(), elements));
    }
  }
  else if (sort_bag::is_bagcomprehension_application(expr))
  {

    data_expression body(sort_bag::arg(expr));
    data_expression_vector variables;
    sort_expression_list domain_of_body_sort(function_sort(body.sort()).domain());
    data_expression_list context = atermpp::make_list(body);

    for(sort_expression_list::const_iterator i = domain_of_body_sort.begin();
        i != domain_of_body_sort.end(); ++i)
    {
      variable var = data::variable(gsMakeDataVarId(gsFreshString2ATermAppl("x",
          (ATerm) static_cast<ATermList>(context), true), static_cast<ATermAppl>(*i)));
      context = atermpp::push_front(context, data_expression(var));
      variables.push_back(var);
    }

    body = data::application(body, variables);
    Part = gsMakeBinder(gsMakeBagComp(), atermpp::convert<data_expression_list>(variables), body);
  }
  return Part;
}

void PrintDataExpr_C(FILE* OutStream,
  ATermAppl DataExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsDataExpr(DataExpr)) ? static_cast<void> (0) : __assert_fail ("gsIsDataExpr(DataExpr)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1587, __PRETTY_FUNCTION__));
  if (gsIsId(DataExpr) || gsIsOpId(DataExpr) || gsIsDataVarId(DataExpr) ||
    gsIsDataAppl(DataExpr)) {
    if (pp_format == ppDebug) {
      PrintPart_Appl_C(OutStream, ATAgetArgument(DataExpr, 0),
        pp_format, ShowSorts, 0);
      if (gsIsDataAppl(DataExpr)) {
        fprints_C(OutStream, "(");

        PrintPart_List_C(OutStream, ATLgetArgument(DataExpr, 1),
          pp_format, ShowSorts, 0, __null, ", ");
        fprints_C(OutStream, ")");
      }
    } else {

      DataExpr = reconstruct_container_expression(DataExpr);
      ATermAppl Head;
      ATermList Args;
      if (!gsIsDataAppl(DataExpr)) {
        Head = DataExpr;
        Args = (ATempty);
      } else {
        Head = ATAgetArgument(DataExpr, 0);
        Args = ATLgetArgument(DataExpr, 1);
      }
      int ArgsLength = ATgetLength(Args);
      if (gsIsOpIdNumericUpCast(Head) && ArgsLength == 1) {

        dbg_prints_C("printing upcast expression\n");
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 0),
          pp_format, ShowSorts, PrecLevel);
      } else if (gsIsIdListEnum(Head)) {

        dbg_prints_C("printing list enumeration\n");
        fprints_C(OutStream, "[");
        PrintPart_List_C(OutStream, Args,
          pp_format, ShowSorts, 0, __null, ", ");
        fprints_C(OutStream, "]");
      } else if (gsIsIdSetEnum(Head)) {

        dbg_prints_C("printing set enumeration\n");
        fprints_C(OutStream, "{");
        PrintPart_List_C(OutStream, Args,
          pp_format, ShowSorts, 0, __null, ", ");
        fprints_C(OutStream, "}");
      } else if (gsIsIdBagEnum(Head)) {

        fprints_C(OutStream, "{");
        PrintPart_BagEnum_C(OutStream, Args,
          pp_format, ShowSorts, 0, __null, ", ");
        fprints_C(OutStream, "}");
      } else if (gsIsIdFuncUpdate(Head) && Args != ATempty) {

        dbg_prints_C("printing function update\n");
        ((ATgetLength(Args)==3) ? static_cast<void> (0) : __assert_fail ("ATgetLength(Args)==3", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1641, __PRETTY_FUNCTION__));
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 0),
           pp_format, ShowSorts, gsPrecIdPrefix());
        fprints_C(OutStream, "[");
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 1),
          pp_format, ShowSorts, 0);
        fprints_C(OutStream, " -> ");
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 2),
          pp_format, ShowSorts, 0);
        fprints_C(OutStream, "]");
      } else if (gsIsIdPrefix(Head, ArgsLength)) {

        dbg_prints_C("printing prefix expression\n");
        PrintPart_Appl_C(OutStream, Head,
          pp_format, ShowSorts, PrecLevel);
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 0),
          pp_format, ShowSorts, gsPrecIdPrefix());
      } else if (gsIsIdInfix(Head, ArgsLength)) {

        dbg_prints_C("printing infix expression\n");
        ATermAppl HeadName = ATAgetArgument(Head, 0);
        if (PrecLevel > gsPrecIdInfix(HeadName))
          fprints_C(OutStream, "(");
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 0),
          pp_format, ShowSorts, gsPrecIdInfixLeft(HeadName));
        fprints_C(OutStream, " ");
        PrintPart_Appl_C(OutStream, Head, pp_format, ShowSorts, PrecLevel);
        fprints_C(OutStream, " ");
        PrintDataExpr_C(OutStream, ATAelementAt(Args, 1),
          pp_format, ShowSorts, gsPrecIdInfixRight(HeadName));
        if (PrecLevel > gsPrecIdInfix(HeadName))
          fprints_C(OutStream, ")");
      } else if (gsIsId(DataExpr)) {

        dbg_prints_C("printing untyped data variable or operation identifier\n");
        PrintPart_Appl_C(OutStream, ATAgetArgument(DataExpr, 0),
          pp_format, ShowSorts, PrecLevel);
      } else if (gsIsOpId(DataExpr) || gsIsDataVarId(DataExpr)) {
        ATermAppl Reconstructed(reconstruct_numeric_expression(DataExpr));

        if (Reconstructed == DataExpr) {
          dbg_prints_C("printing data variable or operation identifier\n");
          PrintPart_Appl_C(OutStream, ATAgetArgument(DataExpr, 0),
            pp_format, ShowSorts, PrecLevel);
          if (ShowSorts) {
            fprints_C(OutStream, ": ");
            PrintPart_Appl_C(OutStream, ATAgetArgument(DataExpr, 1),
              pp_format, ShowSorts, 0);
          }
        }
        else {
          PrintDataExpr_C(OutStream, Reconstructed, pp_format, ShowSorts, PrecLevel);
        }
      } else {
        ATermAppl Reconstructed(reconstruct_numeric_expression(DataExpr));
        if (Reconstructed == DataExpr) {

          dbg_prints_C("printing data application\n");
          PrintDataExpr_C(OutStream, Head, pp_format, ShowSorts, gsPrecIdPrefix());
          fprints_C(OutStream, "(");
          PrintPart_List_C(OutStream, Args, pp_format, ShowSorts, 0, __null, ", ");
          fprints_C(OutStream, ")");
        }
        else {
          dbg_prints_C("printing numeric representation\n");
          PrintDataExpr_C(OutStream, Reconstructed, pp_format, ShowSorts, PrecLevel);
        }
      }
    }
  } else if (gsIsBinder(DataExpr)) {
    dbg_prints_C("printing binder\n");
    ATermAppl BindingOperator = ATAgetArgument(DataExpr, 0);
    if (gsIsSetBagComp(BindingOperator) || gsIsSetComp(BindingOperator)
        || gsIsBagComp(BindingOperator)) {

      dbg_prints_C("printing set/bag comprehension\n");
      fprints_C(OutStream, "{ ");
      ((!((ATbool)(((ATermList)ATLgetArgument(DataExpr,1))->aterm.head == __null && ((ATermList)ATLgetArgument(DataExpr,1))->aterm.tail == __null))) ? static_cast<void> (0) : __assert_fail ("!((ATbool)(((ATermList)ATLgetArgument(DataExpr,1))->aterm.head == __null && ((ATermList)ATLgetArgument(DataExpr,1))->aterm.tail == __null))", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1718, __PRETTY_FUNCTION__));
      PrintDecls_C(OutStream, ATLgetArgument(DataExpr, 1),
        pp_format, __null, ", ");
      fprints_C(OutStream, " | ");
      PrintDataExpr_C(OutStream, ATAgetArgument(DataExpr, 2),
        pp_format, ShowSorts, 0);
      fprints_C(OutStream, " }");
    } else if (gsIsLambda(BindingOperator) || gsIsForall(BindingOperator)
            || gsIsExists(BindingOperator)) {

      dbg_prints_C("printing lambda abstraction or universal/existential quantification\n");
      if (PrecLevel > 1) fprints_C(OutStream, "(");
      fprints_C(OutStream, (gsIsLambda(BindingOperator)?"lambda ":
                                     (gsIsForall(BindingOperator))?"forall ":
                                     "exists "));
      PrintDecls_C(OutStream, ATLgetArgument(DataExpr, 1),
        pp_format, __null, ", ");
      fprints_C(OutStream, ". ");
      PrintPart_Appl_C(OutStream, ATAgetArgument(DataExpr, 2),
        pp_format, ShowSorts, 1);
      if (PrecLevel > 1) fprints_C(OutStream, ")");
    }
  } else if (gsIsWhr(DataExpr)) {

    dbg_prints_C("printing where clause\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    PrintDataExpr_C(OutStream, ATAgetArgument(DataExpr, 0),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, " whr ");
    PrintPart_List_C(OutStream, ATLgetArgument(DataExpr, 1),
      pp_format, ShowSorts, PrecLevel, __null, ", ");
    fprints_C(OutStream, " end");
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  }
}

static void PrintProcExpr_C(FILE* OutStream,
  const ATermAppl ProcExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsProcExpr(ProcExpr)) ? static_cast<void> (0) : __assert_fail ("gsIsProcExpr(ProcExpr)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1757, __PRETTY_FUNCTION__));
  if (gsIsParamId(ProcExpr) || gsIsAction(ProcExpr) || gsIsProcess(ProcExpr)) {

    dbg_prints_C("printing action or process reference\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList Args = ATLgetArgument(ProcExpr, 1);
    if (ATgetLength(Args) > 0) {
      fprints_C(OutStream, "(");
      PrintPart_List_C(OutStream, Args,
        pp_format, ShowSorts, 0, __null, ", ");
      fprints_C(OutStream, ")");
    }
  } else if (gsIsIdAssignment(ProcExpr) || gsIsProcessAssignment(ProcExpr)) {

    dbg_prints_C("printing process assignment\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, PrecLevel);
    fprints_C(OutStream, "(");
    PrintPart_List_C(OutStream, ATLgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 0, __null, ", ");
    fprints_C(OutStream, ")");
  } else if (gsIsDelta(ProcExpr)) {

    dbg_prints_C("printing delta\n");
    fprints_C(OutStream, "delta");
  } else if (gsIsTau(ProcExpr)) {

    dbg_prints_C("printing tau\n");
    fprints_C(OutStream, "tau");
  } else if (gsIsChoice(ProcExpr)) {

    dbg_prints_C("printing choice\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 1);
    fprints_C(OutStream, " + ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (gsIsSum(ProcExpr)) {

    dbg_prints_C("printing summation\n");
    if (PrecLevel > 1) fprints_C(OutStream, "(");
    fprints_C(OutStream, "sum ");
    PrintDecls_C(OutStream, ATLgetArgument(ProcExpr, 0),
      pp_format, __null, ", ");
    fprints_C(OutStream, ". ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 1);
    if (PrecLevel > 1) fprints_C(OutStream, ")");
  } else if (gsIsMerge(ProcExpr) || gsIsLMerge(ProcExpr)) {

    dbg_prints_C("printing merge or left merge\n");
    if (PrecLevel > 2) fprints_C(OutStream, "(");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 3);
    if (gsIsMerge(ProcExpr)) {
      fprints_C(OutStream, " || ");
    } else {
      fprints_C(OutStream, " ||_ ");
    }
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 2);
    if (PrecLevel > 2) fprints_C(OutStream, ")");
  } else if (gsIsBInit(ProcExpr)) {

    dbg_prints_C("printing bounded initialisation\n");
    if (PrecLevel > 3) fprints_C(OutStream, "(");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 4);
    fprints_C(OutStream, " << ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 3);
    if (PrecLevel > 3) fprints_C(OutStream, ")");
  } else if (gsIsIfThen(ProcExpr)) {

    dbg_prints_C("printing if then\n");
    if (PrecLevel > 4) fprints_C(OutStream, "(");
    PrintDataExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, gsPrecIdPrefix());
    fprints_C(OutStream, " -> ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 5);
    if (PrecLevel > 4) fprints_C(OutStream, ")");
  } else if (gsIsIfThenElse(ProcExpr)) {

    dbg_prints_C("printing if then else\n");
    if (PrecLevel > 4) fprints_C(OutStream, "(");
    PrintDataExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, gsPrecIdPrefix());
    fprints_C(OutStream, " -> ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 5);
    ATermAppl ProcExprElse = ATAgetArgument(ProcExpr, 2);
    fprints_C(OutStream, " <> ");
    PrintProcExpr_C(OutStream, ProcExprElse,
      pp_format, ShowSorts, 5);
    if (PrecLevel > 4) fprints_C(OutStream, ")");
  } else if (gsIsSeq(ProcExpr)) {

    dbg_prints_C("printing sequential composition\n");
    if (PrecLevel > 5) fprints_C(OutStream, "(");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 6);
    fprints_C(OutStream, " . ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 5);
    if (PrecLevel > 5) fprints_C(OutStream, ")");
  } else if (gsIsAtTime(ProcExpr)) {

    dbg_prints_C("printing at expression\n");
    if (PrecLevel > 6) fprints_C(OutStream, "(");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 6);
    fprints_C(OutStream, " @ ");
    PrintDataExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, gsPrecIdPrefix());
    if (PrecLevel > 6) fprints_C(OutStream, ")");
  } else if (gsIsSync(ProcExpr)) {

    dbg_prints_C("printing sync\n");
    if (PrecLevel > 7) fprints_C(OutStream, "(");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 8);
    fprints_C(OutStream, " | ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 7);
    if (PrecLevel > 7) fprints_C(OutStream, ")");
  } else if (gsIsBlock(ProcExpr) || gsIsHide(ProcExpr) || gsIsRename(ProcExpr) ||
      gsIsComm(ProcExpr) || gsIsAllow(ProcExpr)) {

    dbg_prints_C("printing process quantification\n");
    if (gsIsBlock(ProcExpr)) {
      fprints_C(OutStream, "block");
    } else if (gsIsHide(ProcExpr)) {
      fprints_C(OutStream, "hide");
    } else if (gsIsRename(ProcExpr)) {
      fprints_C(OutStream, "rename");
    } else if (gsIsComm(ProcExpr)) {
      fprints_C(OutStream, "comm");
    } else {
      fprints_C(OutStream, "allow");
    }
    fprints_C(OutStream, "({");
    PrintPart_List_C(OutStream, ATLgetArgument(ProcExpr, 0),
      pp_format, ShowSorts, 0, __null, ", ");
    fprints_C(OutStream, "}, ");
    PrintProcExpr_C(OutStream, ATAgetArgument(ProcExpr, 1),
      pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  }
}

static void PrintStateFrm_C(FILE* OutStream,
  const ATermAppl StateFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsStateFrm(StateFrm)) ? static_cast<void> (0) : __assert_fail ("gsIsStateFrm(StateFrm)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 1914, __PRETTY_FUNCTION__));
  if (gsIsDataExpr(StateFrm)) {

    dbg_prints_C("printing data expression\n");
    fprints_C(OutStream, "val(");
    PrintDataExpr_C(OutStream, StateFrm, pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  } else if (gsIsStateTrue(StateFrm)) {

    dbg_prints_C("printing true\n");
    fprints_C(OutStream, "true");
  } else if (gsIsStateFalse(StateFrm)) {

    dbg_prints_C("printing false\n");
    fprints_C(OutStream, "false");
  } else if (gsIsStateYaled(StateFrm)) {

    dbg_prints_C("printing yaled\n");
    fprints_C(OutStream, "yaled");
  } else if (gsIsStateDelay(StateFrm)) {

    dbg_prints_C("printing delay\n");
    fprints_C(OutStream, "delay");
  } else if (gsIsStateYaledTimed(StateFrm)) {

    dbg_prints_C("printing timed yaled\n");
    fprints_C(OutStream, "yaled @ ");
    PrintDataExpr_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, gsPrecIdPrefix());
  } else if (gsIsStateDelayTimed(StateFrm)) {

    dbg_prints_C("printing timed delay\n");
    fprints_C(OutStream, "delay @ ");
    PrintDataExpr_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, gsPrecIdPrefix());
  } else if (gsIsStateVar(StateFrm)) {

    dbg_prints_C("printing fixpoint variable\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList Args = ATLgetArgument(StateFrm, 1);
    if (ATgetLength(Args) > 0) {
      fprints_C(OutStream, "(");
      PrintPart_List_C(OutStream, Args,
        pp_format, ShowSorts, 0, __null, ", ");
      fprints_C(OutStream, ")");
    }
  } else if (gsIsStateForall(StateFrm) || gsIsStateExists(StateFrm)) {

    dbg_prints_C("printing quantification\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    if (gsIsStateForall(StateFrm)) {
      fprints_C(OutStream, "forall ");
    } else {
      fprints_C(OutStream, "exists ");
    }
    PrintDecls_C(OutStream, ATLgetArgument(StateFrm, 0),
      pp_format, __null, ", ");
    fprints_C(OutStream, ". ");
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 1),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (gsIsStateNu(StateFrm) || gsIsStateMu(StateFrm)) {

    dbg_prints_C("printing fixpoint quantification\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    if (gsIsStateNu(StateFrm)) {
      fprints_C(OutStream, "nu ");
    } else {
      fprints_C(OutStream, "mu ");
    }
    PrintPart_Appl_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList DataVarInits = ATLgetArgument(StateFrm, 1);
    if (ATgetLength(DataVarInits) > 0) {
      fprints_C(OutStream, "(");
      PrintPart_List_C(OutStream, DataVarInits,
        pp_format, ShowSorts, 0, __null, ", ");
      fprints_C(OutStream, ")");
    }
    fprints_C(OutStream, ". ");
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 2),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (gsIsStateImp(StateFrm)) {

    dbg_prints_C("printing implication\n");
    if (PrecLevel > 1) fprints_C(OutStream, "(");
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, 2);
    fprints_C(OutStream, " => ");
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 1),
      pp_format, ShowSorts, 1);
    if (PrecLevel > 1) fprints_C(OutStream, ")");
  } else if (gsIsStateAnd(StateFrm) || gsIsStateOr(StateFrm)) {

    dbg_prints_C("printing conjunction or disjunction\n");
    if (PrecLevel > 2) fprints_C(OutStream, "(");
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, 3);
    if (gsIsStateAnd(StateFrm)) {
      fprints_C(OutStream, " && ");
    } else {
      fprints_C(OutStream, " || ");
    }
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 1),
      pp_format, ShowSorts, 2);
    if (PrecLevel > 2) fprints_C(OutStream, ")");
  } else if (gsIsStateNot(StateFrm)) {

    dbg_prints_C("printing negation\n");
    if (PrecLevel > 3) fprints_C(OutStream, "(");
    fprints_C(OutStream, "!");
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, 3);
    if (PrecLevel > 3) fprints_C(OutStream, ")");
  } else if (gsIsStateMust(StateFrm) || gsIsStateMay(StateFrm)) {

    dbg_prints_C("printing must or may\n");
    if (PrecLevel > 3) fprints_C(OutStream, "(");
    if (gsIsStateMust(StateFrm)) {
      fprints_C(OutStream, "[");
    } else {
      fprints_C(OutStream, "<");
    }
    PrintRegFrm_C(OutStream, ATAgetArgument(StateFrm, 0),
      pp_format, ShowSorts, 0);
    if (gsIsStateMust(StateFrm)) {
      fprints_C(OutStream, "]");
    } else {
      fprints_C(OutStream, ">");
    }
    PrintStateFrm_C(OutStream, ATAgetArgument(StateFrm, 1),
      pp_format, ShowSorts, 3);
    if (PrecLevel > 3) fprints_C(OutStream, ")");
  }
}

static void PrintRegFrm_C(FILE* OutStream,
  const ATermAppl RegFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsRegFrm(RegFrm)) ? static_cast<void> (0) : __assert_fail ("gsIsRegFrm(RegFrm)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 2055, __PRETTY_FUNCTION__));
  if (gsIsActFrm(RegFrm)) {

    dbg_prints_C("printing action formula\n");
    PrintActFrm_C(OutStream, RegFrm, pp_format, ShowSorts, 0);
  } else if (gsIsRegNil(RegFrm)) {

    dbg_prints_C("printing nil\n");
    fprints_C(OutStream, "nil");
  } else if (gsIsRegAlt(RegFrm)) {

    dbg_prints_C("printing alternative composition\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    PrintRegFrm_C(OutStream, ATAgetArgument(RegFrm, 0),
      pp_format, ShowSorts, 1);
    fprints_C(OutStream, " + ");
    PrintRegFrm_C(OutStream, ATAgetArgument(RegFrm, 1),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (gsIsRegSeq(RegFrm)) {

    dbg_prints_C("printing sequential composition\n");
    if (PrecLevel > 1) fprints_C(OutStream, "(");
    PrintRegFrm_C(OutStream, ATAgetArgument(RegFrm, 0),
      pp_format, ShowSorts, 2);
    fprints_C(OutStream, " . ");
    PrintRegFrm_C(OutStream, ATAgetArgument(RegFrm, 1),
      pp_format, ShowSorts, 1);
    if (PrecLevel > 1) fprints_C(OutStream, ")");
  } else if (gsIsRegTransOrNil(RegFrm) || gsIsRegTrans(RegFrm)) {

    dbg_prints_C("printing (reflexive) transitive closure\n");
    if (PrecLevel > 2) fprints_C(OutStream, "(");
    PrintRegFrm_C(OutStream, ATAgetArgument(RegFrm, 0),
      pp_format, ShowSorts, 2);
    if (gsIsRegTransOrNil(RegFrm)) {
      fprints_C(OutStream, "*");
    } else {
      fprints_C(OutStream, "+");
    }
    if (PrecLevel > 2) fprints_C(OutStream, ")");
  }
}

static void PrintActFrm_C(FILE* OutStream,
  const ATermAppl ActFrm, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsActFrm(ActFrm)) ? static_cast<void> (0) : __assert_fail ("gsIsActFrm(ActFrm)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 2102, __PRETTY_FUNCTION__));
  if (gsIsDataExpr(ActFrm)) {

    dbg_prints_C("printing data expression\n");
    fprints_C(OutStream, "val(");
    PrintDataExpr_C(OutStream, ActFrm, pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  } else if (gsIsMultAct(ActFrm)) {

    PrintPart_Appl_C(OutStream, ActFrm, pp_format, ShowSorts, 0);
  } else if (gsIsActTrue(ActFrm)) {

    dbg_prints_C("printing true\n");
    fprints_C(OutStream, "true");
  } else if (gsIsActFalse(ActFrm)) {

    dbg_prints_C("printing false\n");
    fprints_C(OutStream, "false");
  } else if (gsIsActForall(ActFrm) || gsIsActExists(ActFrm)) {

    dbg_prints_C("printing quantification\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    if (gsIsActForall(ActFrm)) {
      fprints_C(OutStream, "forall ");
    } else {
      fprints_C(OutStream, "exists ");
    }
    PrintDecls_C(OutStream, ATLgetArgument(ActFrm, 0),
      pp_format, __null, ", ");
    fprints_C(OutStream, ". ");
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 1),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (gsIsActImp(ActFrm)) {

    dbg_prints_C("printing implication\n");
    if (PrecLevel > 1) fprints_C(OutStream, "(");
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 0),
      pp_format, ShowSorts, 2);
    fprints_C(OutStream, " => ");
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 1),
      pp_format, ShowSorts, 1);
    if (PrecLevel > 1) fprints_C(OutStream, ")");
  } else if (gsIsActAnd(ActFrm) || gsIsActOr(ActFrm)) {

    dbg_prints_C("printing conjunction or disjunction\n");
    if (PrecLevel > 2) fprints_C(OutStream, "(");
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 0),
      pp_format, ShowSorts, 3);
    if (gsIsActAnd(ActFrm)) {
      fprints_C(OutStream, " && ");
    } else {
      fprints_C(OutStream, " || ");
    }
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 1),
      pp_format, ShowSorts, 2);
    if (PrecLevel > 2) fprints_C(OutStream, ")");
  } else if (gsIsActAt(ActFrm)) {

    dbg_prints_C("printing at expression\n");
    if (PrecLevel > 3) fprints_C(OutStream, "(");
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 0),
      pp_format, ShowSorts, 3);
    fprints_C(OutStream, " @ ");
    PrintDataExpr_C(OutStream, ATAgetArgument(ActFrm, 1),
      pp_format, ShowSorts, gsPrecIdPrefix());
    if (PrecLevel > 3) fprints_C(OutStream, ")");
  } else if (gsIsActNot(ActFrm)) {

    dbg_prints_C("printing negation\n");
    if (PrecLevel > 4) fprints_C(OutStream, "(");
    fprints_C(OutStream, "!");
    PrintActFrm_C(OutStream, ATAgetArgument(ActFrm, 0),
      pp_format, ShowSorts, 4);
    if (PrecLevel > 4) fprints_C(OutStream, ")");
  }
}

static void PrintPBExpr_C(FILE* OutStream,
  const ATermAppl PBExpr, t_pp_format pp_format, bool ShowSorts, int PrecLevel)
{
  ((gsIsPBExpr(PBExpr)) ? static_cast<void> (0) : __assert_fail ("gsIsPBExpr(PBExpr)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 2183, __PRETTY_FUNCTION__));
  if (gsIsDataExpr(PBExpr)) {

    dbg_prints_C("printing data expression\n");
    fprints_C(OutStream, "val(");
    PrintDataExpr_C(OutStream, PBExpr, pp_format, ShowSorts, 0);
    fprints_C(OutStream, ")");
  } else if (gsIsPBESTrue(PBExpr)) {

    dbg_prints_C("printing true\n");
    fprints_C(OutStream, "true");
  } else if (gsIsPBESFalse(PBExpr)) {

    dbg_prints_C("printing false\n");
    fprints_C(OutStream, "false");
  } else if (gsIsPropVarInst(PBExpr)) {

    dbg_prints_C("printing propositional variable instance\n");
    PrintPart_Appl_C(OutStream, ATAgetArgument(PBExpr, 0),
      pp_format, ShowSorts, PrecLevel);
    ATermList Args = ATLgetArgument(PBExpr, 1);
    if (ATgetLength(Args) > 0) {
      fprints_C(OutStream, "(");
      PrintPart_List_C(OutStream, Args,
        pp_format, ShowSorts, 0, __null, ", ");
      fprints_C(OutStream, ")");
    }
  } else if (gsIsPBESForall(PBExpr) || gsIsPBESExists(PBExpr)) {

    dbg_prints_C("printing quantification\n");
    if (PrecLevel > 0) fprints_C(OutStream, "(");
    if (gsIsPBESForall(PBExpr)) {
      fprints_C(OutStream, "forall ");
    } else {
      fprints_C(OutStream, "exists ");
    }
    PrintDecls_C(OutStream, ATLgetArgument(PBExpr, 0),
      pp_format, __null, ", ");
    fprints_C(OutStream, ". ");
    PrintPBExpr_C(OutStream, ATAgetArgument(PBExpr, 1),
      pp_format, ShowSorts, 0);
    if (PrecLevel > 0) fprints_C(OutStream, ")");
  } else if (gsIsPBESImp(PBExpr)) {

    dbg_prints_C("printing implication\n");
    if (PrecLevel > 1) fprints_C(OutStream, "(");
    PrintPBExpr_C(OutStream, ATAgetArgument(PBExpr, 0),
      pp_format, ShowSorts, 2);
    fprints_C(OutStream, " => ");
    PrintPBExpr_C(OutStream, ATAgetArgument(PBExpr, 1),
      pp_format, ShowSorts, 1);
    if (PrecLevel > 1) fprints_C(OutStream, ")");
  } else if (gsIsPBESAnd(PBExpr) || gsIsPBESOr(PBExpr)) {

    dbg_prints_C("printing conjunction or disjunction\n");
    if (PrecLevel > 2) fprints_C(OutStream, "(");
    PrintPBExpr_C(OutStream, ATAgetArgument(PBExpr, 0),
      pp_format, ShowSorts, 3);
    if (gsIsPBESAnd(PBExpr)) {
      fprints_C(OutStream, " && ");
    } else {
      fprints_C(OutStream, " || ");
    }
    PrintPBExpr_C(OutStream, ATAgetArgument(PBExpr, 1),
      pp_format, ShowSorts, 2);
    if (PrecLevel > 2) fprints_C(OutStream, ")");
  } else if (gsIsPBESNot(PBExpr)) {

    dbg_prints_C("printing negation\n");
    if (PrecLevel > 3) fprints_C(OutStream, "(");
    fprints_C(OutStream, "!");
    PrintPBExpr_C(OutStream, ATAgetArgument(PBExpr, 0),
      pp_format, ShowSorts, 3);
    if (PrecLevel > 3) fprints_C(OutStream, ")");
  }
}

void PrintLinearProcessSummand_C(FILE* OutStream,
  const ATermAppl Summand, t_pp_format pp_format, bool ShowSorts)
{
  ((gsIsLinearProcessSummand(Summand)) ? static_cast<void> (0) : __assert_fail ("gsIsLinearProcessSummand(Summand)", "/scratch/mcrl2_regressiontest/trunk/libraries/core/include/mcrl2/core/detail/print_implementation.h", 2263, __PRETTY_FUNCTION__));
  dbg_prints_C("printing LPS summand\n");

  ATermList SumVarDecls = ATLgetArgument(Summand, 0);
  if (ATgetLength(SumVarDecls) > 0) {
    fprints_C(OutStream, "sum ");
    PrintDecls_C(OutStream, SumVarDecls, pp_format, __null, ",");
    fprints_C(OutStream, ".\n         ");
  }

  ATermAppl Cond = ATAgetArgument(Summand, 1);
  if ( !data::sort_bool::is_true_function_symbol(data::data_expression(Cond))) {
    PrintDataExpr_C(OutStream, Cond, pp_format, ShowSorts, gsPrecIdPrefix());
    fprints_C(OutStream, " ->\n         ");
  }

  ATermAppl MultAct = ATAgetArgument(Summand, 2);
  ATermAppl Time = ATAgetArgument(Summand, 3);
  bool IsTimed = !gsIsNil(Time);
  PrintPart_Appl_C(OutStream, MultAct, pp_format, ShowSorts,
    (IsTimed)?6:5);

  if (IsTimed) {
    fprints_C(OutStream, " @ ");
    PrintDataExpr_C(OutStream, Time, pp_format, ShowSorts, gsPrecIdPrefix());
  }

  if (!gsIsDelta(MultAct)) {
    fprints_C(OutStream, " .\n         ");
    fprints_C(OutStream, "P");
    ATermList Assignments = ATLgetArgument(Summand, 4);
    fprints_C(OutStream, "(");
    PrintPart_List_C(OutStream, Assignments,
      pp_format, ShowSorts, 0, __null, ", ");
    fprints_C(OutStream, ")");
  }
}

ATermList GetAssignmentsRHS(ATermList Assignments) {
  ATermList l = (ATempty);
  while (!((ATbool)(((ATermList)Assignments)->aterm.head == __null && ((ATermList)Assignments)->aterm.tail == __null))) {
    l = ATinsert(l, (((ATermAppl)ATAgetFirst(Assignments))->aterm.arg[1]));
    Assignments = (((ATermList)Assignments)->aterm.tail);
  }
  return ATreverse(l);
}

ATermList gsGroupDeclsBySort(ATermList Decls)
{
  if (!((ATbool)(((ATermList)Decls)->aterm.head == __null && ((ATermList)Decls)->aterm.tail == __null))) {
    ATermTable SortDeclsTable = ATtableCreate(2*ATgetLength(Decls), 50);


    while (!((ATbool)(((ATermList)Decls)->aterm.head == __null && ((ATermList)Decls)->aterm.tail == __null)))
    {
      ATermAppl Decl = ATAgetFirst(Decls);
      ATermAppl DeclSort = ATAgetArgument(Decl, 1);
      ATermList CorDecls = ATLtableGet(SortDeclsTable, (ATerm) DeclSort);
      ATtablePut(SortDeclsTable, (ATerm) DeclSort,
        (CorDecls == __null)
          ?(ATerm) ATmakeList1((ATerm) Decl)
          :(ATerm) ATinsert(CorDecls, (ATerm) Decl)
      );
      Decls = (((ATermList)Decls)->aterm.tail);
    }

    ATermList DeclSorts = ATtableKeys(SortDeclsTable);
    ATermList Result = (ATempty);
    while (!((ATbool)(((ATermList)DeclSorts)->aterm.head == __null && ((ATermList)DeclSorts)->aterm.tail == __null)))
    {
      Result = ATconcat(
        ATLtableGet(SortDeclsTable, (((ATermList)DeclSorts)->aterm.head)),
        Result);
      DeclSorts = (((ATermList)DeclSorts)->aterm.tail);
    }
    ATtableDestroy(SortDeclsTable);
    return ATreverse(Result);
  } else {

    return Decls;
  }
}

bool gsHasConsistentContext(const ATermTable DataVarDecls,
  const ATermAppl Part)
{
  bool Result = true;
  if (gsIsDataEqn(Part) || gsIsProcEqn(Part)) {

    ATermList VarDecls = ATLgetArgument(Part, 0);
    int n = ATgetLength(VarDecls);
    for (int i = 0; i < n && Result; i++) {

      ATermAppl VarDecl = ATAelementAt(VarDecls, i);
      ATermAppl CorVarDecl =
        ATAtableGet(DataVarDecls, (((ATermAppl)VarDecl)->aterm.arg[0]));
      if (CorVarDecl != __null) {

        Result = (((ATbool)((ATerm)(VarDecl) == (ATerm)(CorVarDecl))) == ATtrue);
      }
    }
  } else if (gsIsOpId(Part) || gsIsId(Part)) {


    Result = (ATtableGet(DataVarDecls, (((ATermAppl)Part)->aterm.arg[0])) == __null);
  }

  if (Result) {
    AFun Head = ((AFun)(((Part)->header) >> 34));
    int NrArgs = ((unsigned int)((unsigned long)((at_lookup_table_alias[(Head)]->header) >> 34)));
    for (int i = 0; i < NrArgs && Result; i++) {
      ATerm Arg = (((ATermAppl)Part)->aterm.arg[i]);
      if (((unsigned int)((((Arg)->header) & (((1 << 3)-1) << 4)) >> 4)) == 1L)
        Result = gsHasConsistentContext(DataVarDecls, (ATermAppl) Arg);
      else
        Result = gsHasConsistentContextList(DataVarDecls, (ATermList) Arg);
    }
  }
  return Result;
}

bool gsHasConsistentContextList(const ATermTable DataVarDecls,
  const ATermList Parts)
{
  bool Result = true;
  ATermList l = Parts;
  while (!((ATbool)(((ATermList)l)->aterm.head == __null && ((ATermList)l)->aterm.tail == __null)) && Result) {
    Result = gsHasConsistentContext(DataVarDecls, ATAgetFirst(l));
    l = (((ATermList)l)->aterm.tail);
  }
  return Result;
}

bool gsIsOpIdNumericUpCast(ATermAppl DataExpr)
{
  if (!gsIsOpId(DataExpr)) {
    return false;
  }
  return
    data::sort_nat::is_pos2nat_function_symbol(data::data_expression(DataExpr)) ||
    data::sort_int::is_pos2int_function_symbol(data::data_expression(DataExpr)) ||
    data::sort_real::is_pos2real_function_symbol(data::data_expression(DataExpr)) ||
    data::sort_int::is_nat2int_function_symbol(data::data_expression(DataExpr)) ||
    data::sort_real::is_nat2real_function_symbol(data::data_expression(DataExpr)) ||
    data::sort_real::is_int2real_function_symbol(data::data_expression(DataExpr))
    ;
}

bool gsIsIdListEnum(ATermAppl DataExpr)
{
  if (!(gsIsId(DataExpr) || gsIsOpId(DataExpr))) {
    return false;
  }
  return ATAgetArgument(DataExpr, 0) == data::sort_list::list_enumeration_name();
}

bool gsIsIdSetEnum(ATermAppl DataExpr)
{
  if (!(gsIsId(DataExpr) || gsIsOpId(DataExpr))) {
    return false;
  }
  return ATAgetArgument(DataExpr, 0) == data::sort_set::set_enumeration_name();
}

bool gsIsIdBagEnum(ATermAppl DataExpr)
{
  if (!(gsIsId(DataExpr) || gsIsOpId(DataExpr))) {
    return false;
  }
  return ATAgetArgument(DataExpr, 0) == data::sort_bag::bag_enumeration_name();
}

bool gsIsIdFuncUpdate(ATermAppl DataExpr)
{
  if (!(gsIsId(DataExpr) || gsIsOpId(DataExpr))) {
    return false;
  }
  return ATAgetArgument(DataExpr, 0) == data::function_update_name();
}

bool gsIsIdPrefix(ATermAppl DataExpr, int ArgsLength)
{
  if (!(gsIsId(DataExpr) || gsIsOpId(DataExpr))) {
    return false;
  }
  if (ArgsLength != 1) {
    return false;
  }
  ATermAppl IdName = ATAgetArgument(DataExpr, 0);
  return
     (IdName == data::sort_bool::not_name()) ||
     (IdName == data::sort_int::negate_name()) ||
     (IdName == data::sort_list::count_name()) ||
     (IdName == data::sort_set::setcomplement_name());
}

bool gsIsIdInfix(ATermAppl DataExpr, int ArgsLength)
{
  if (!(gsIsId(DataExpr) || gsIsOpId(DataExpr))) {
    return false;
  }
  if (ArgsLength != 2) {
    return false;
  }
  ATermAppl IdName = ATAgetArgument(DataExpr, 0);
  return
     (IdName == data::sort_bool::implies_name()) ||
     (IdName == data::sort_bool::and_name()) ||
     (IdName == data::sort_bool::or_name()) ||
     (IdName == data::detail::equal_symbol()) ||
     (IdName == data::detail::not_equal_symbol()) ||
     (IdName == data::detail::less_symbol()) ||
     (IdName == data::detail::less_equal_symbol()) ||
     (IdName == data::detail::greater_symbol()) ||
     (IdName == data::detail::greater_equal_symbol()) ||
     (IdName == data::sort_list::in_name()) ||
     (IdName == data::sort_list::cons_name()) ||
     (IdName == data::sort_list::snoc_name()) ||
     (IdName == data::sort_list::concat_name()) ||
     (IdName == data::sort_real::plus_name()) ||
     (IdName == data::sort_real::minus_name()) ||
     (IdName == data::sort_set::setunion_name()) ||
     (IdName == data::sort_set::setdifference_name()) ||
     (IdName == data::sort_bag::bagjoin_name()) ||
     (IdName == data::sort_bag::bagdifference_name()) ||
     (IdName == data::sort_int::div_name()) ||
     (IdName == data::sort_int::mod_name()) ||
     (IdName == data::sort_real::divides_name()) ||
     (IdName == data::sort_int::times_name()) ||
     (IdName == data::sort_list::element_at_name()) ||
     (IdName == data::sort_set::setintersection_name()) ||
     (IdName == data::sort_bag::bagintersect_name());
}

int gsPrecIdPrefix()
{
  return 13;
}

int gsPrecIdInfix(ATermAppl IdName)
{
  if (IdName == data::sort_bool::implies_name()) {
    return 2;
  } else if ((IdName == data::sort_bool::and_name()) || (IdName == data::sort_bool::or_name())) {
    return 3;
  } else if ((IdName == data::detail::equal_symbol()) || (IdName == data::detail::not_equal_symbol())) {
    return 4;
  } else if (
      (IdName == data::detail::less_symbol()) || (IdName == data::detail::less_equal_symbol()) ||
      (IdName == data::detail::greater_symbol()) || (IdName == data::detail::greater_equal_symbol()) ||
      (IdName == data::sort_list::in_name())
      ) {
    return 5;
  } else if ((IdName == data::sort_list::cons_name())) {
    return 6;
  } else if ((IdName == data::sort_list::snoc_name())) {
    return 7;
  } else if ((IdName == data::sort_list::concat_name())) {
    return 8;
  } else if (
      (IdName == data::sort_real::plus_name()) || (IdName == data::sort_real::minus_name()) ||
      (IdName == data::sort_set::setunion_name()) || (IdName == data::sort_set::setdifference_name()) ||
      (IdName == data::sort_bag::bagjoin_name()) || (IdName == data::sort_bag::bagdifference_name())
      ) {
    return 9;
  } else if ((IdName == data::sort_int::div_name()) || (IdName == data::sort_int::mod_name()) ||
      (IdName == data::sort_real::divides_name())) {
    return 10;
  } else if (
      (IdName == data::sort_int::times_name()) || (IdName == data::sort_list::element_at_name()) ||
      (IdName == data::sort_set::setintersection_name()) ||
      (IdName == data::sort_bag::bagintersect_name())
      ){
    return 11;
  } else {

    return -1;
  }
}

int gsPrecIdInfixLeft(ATermAppl IdName)
{
  if (IdName == data::sort_bool::implies_name()) {
    return 3;
  } else if ((IdName == data::sort_bool::and_name()) || (IdName == data::sort_bool::or_name())) {
    return 4;
  } else if ((IdName == data::detail::equal_symbol()) || (IdName == data::detail::not_equal_symbol())) {
    return 5;
  } else if (
      (IdName == data::detail::less_symbol()) || (IdName == data::detail::less_equal_symbol()) ||
      (IdName == data::detail::greater_symbol()) || (IdName == data::detail::greater_equal_symbol()) ||
      (IdName == data::sort_list::in_name())
      ) {
    return 6;
  } else if ((IdName == data::sort_list::cons_name())) {
    return 9;
  } else if ((IdName == data::sort_list::snoc_name())) {
    return 7;
  } else if ((IdName == data::sort_list::concat_name())) {
    return 8;
  } else if (
      (IdName == data::sort_real::plus_name()) || (IdName == data::sort_real::minus_name()) ||
      (IdName == data::sort_set::setunion_name()) || (IdName == data::sort_set::setdifference_name()) ||
      (IdName == data::sort_bag::bagjoin_name()) || (IdName == data::sort_bag::bagdifference_name())
      ) {
    return 9;
  } else if ((IdName == data::sort_int::div_name()) || (IdName == data::sort_int::mod_name()) ||
      (IdName == data::sort_real::divides_name())) {
    return 10;
  } else if (
      (IdName == data::sort_int::times_name()) || (IdName == data::sort_list::element_at_name()) ||
      (IdName == data::sort_set::setintersection_name()) ||
      (IdName == data::sort_bag::bagintersect_name())
      ){
    return 11;
  } else {

    return -1;
  }
}

int gsPrecIdInfixRight(ATermAppl IdName)
{
  if (IdName == data::sort_bool::implies_name()) {
    return 2;
  } else if ((IdName == data::sort_bool::and_name()) || (IdName == data::sort_bool::or_name())) {
    return 3;
  } else if ((IdName == data::detail::equal_symbol()) || (IdName == data::detail::not_equal_symbol())) {
    return 4;
  } else if (
      (IdName == data::detail::less_symbol()) || (IdName == data::detail::less_equal_symbol()) ||
      (IdName == data::detail::greater_symbol()) || (IdName == data::detail::greater_equal_symbol()) ||
      (IdName == data::sort_list::in_name())
      ) {
    return 6;
  } else if ((IdName == data::sort_list::cons_name())) {
    return 6;
  } else if ((IdName == data::sort_list::snoc_name())) {
    return 9;
  } else if ((IdName == data::sort_list::concat_name())) {
    return 9;
  } else if (
      (IdName == data::sort_real::plus_name()) || (IdName == data::sort_real::minus_name()) ||
      (IdName == data::sort_set::setunion_name()) || (IdName == data::sort_set::setdifference_name()) ||
      (IdName == data::sort_bag::bagjoin_name()) || (IdName == data::sort_bag::bagdifference_name())
      ) {
    return 10;
  } else if ((IdName == data::sort_int::div_name()) || (IdName == data::sort_int::mod_name()) ||
      (IdName == data::sort_real::divides_name())) {
    return 11;
  } else if (
      (IdName == data::sort_int::times_name()) || (IdName == data::sort_list::element_at_name()) ||
      (IdName == data::sort_set::setintersection_name()) ||
      (IdName == data::sort_bag::bagintersect_name())
      ){
    return 12;
  } else {

    return -1;
  }
}
    }
  }
}
# 17 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp" 2

using namespace mcrl2::core::detail;
using boost::intmax_t;

namespace mcrl2 {
  namespace core {

void PrintPart_C(FILE *OutStream, const ATerm Part, t_pp_format pp_format)
{
  PrintPart__C(OutStream, Part, pp_format);
}

int gsprintf(const char *format, ...)
{
  int result = 0;
  va_list args;

  __builtin_va_start(args,format);
  result = gsvfprintf(stdout, format, args);
  __builtin_va_end(args);

  return result;
}

int gsfprintf(FILE *stream, const char *format, ...)
{
  int result = 0;
  va_list args;

  __builtin_va_start(args,format);
  result = gsvfprintf(stream, format, args);
  __builtin_va_end(args);

  return result;
}

int gsvfprintf(FILE *stream, const char *format, va_list args)
{
  const char *p;
  char *s;
  char fmt[32];
  int result = 0;

  for (p = format; *p; p++)
  {
    if (*p != '%')
    {
      fputc(*p, stream);
      continue;
    }

    s = fmt;
    *s++ = *p++;
    if ( *p == '%' )
    {
      fputc('%',stream);
      continue;
    }
    while (!isalpha((int) *p))
      *s++ = *p++;
    bool islonglong = false;
    bool islong = false;
    bool islongdouble = false;
    bool isintmax = false;
    bool issize = false;
    bool isptrdiff = false;
    switch ( *p )
    {
      case 'l':
        *s++ = *p++;
        if ( (*p) == 'l' )
        {
          *s++ = *p++;
          islonglong = true;
        } else {
          islong = true;
        }
        break;
      case 'h':
        *s++ = *p++;
        if ( (*p) == 'h' )
          *s++ = *p++;
        break;
      case 'L':
        *s++ = *p++;
        islongdouble = true;
        break;
      case 'j':
        *s++ = *p++;
        isintmax = true;
        break;
      case 'z':
        *s++ = *p++;
        issize = true;
        break;
      case 't':
        *s++ = *p++;
        isptrdiff = true;
        break;
      default:
        break;
    }
    *s++ = *p;
    *s = '\0';

    switch (*p)
    {
      case 'c':
        fprintf(stream, fmt, __builtin_va_arg(args,int));
        break;

      case 'd':
      case 'i':
      case 'o':
      case 'u':
      case 'x':
      case 'X':
        if ( islong )
          fprintf(stream, fmt, __builtin_va_arg(args,long int));
        else if ( islonglong )
          fprintf(stream, fmt, __builtin_va_arg(args,boost::int64_t));
        else if ( isintmax )
          fprintf(stream, fmt, __builtin_va_arg(args,intmax_t));
        else if ( issize )
          fprintf(stream, fmt, __builtin_va_arg(args,size_t));
        else if ( isptrdiff )
          fprintf(stream, fmt, __builtin_va_arg(args,ptrdiff_t));
        else
          fprintf(stream, fmt, __builtin_va_arg(args,int));
        break;

      case 'a':
      case 'A':
      case 'e':
      case 'E':
      case 'f':
      case 'g':
      case 'G':
        if ( islongdouble )
          fprintf(stream, fmt, __builtin_va_arg(args,long double));
        else
          fprintf(stream, fmt, __builtin_va_arg(args,double));
        break;

      case 'n':
      case 'p':
        fprintf(stream, fmt, __builtin_va_arg(args,void *));
        break;

      case 's':
        fprintf(stream, fmt, __builtin_va_arg(args,char *));
        break;





      case 'P':
        PrintPart_C(stream, __builtin_va_arg(args,ATerm), ppDefault);
        break;
# 186 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp"
      case 'T':
        fmt[strlen(fmt)-1] = 't';
        ATfprintf(stream, fmt, __builtin_va_arg(args,ATerm));
        break;




      case 'F':
        fmt[strlen(fmt)-1] = 'y';
        ATfprintf(stream, fmt, __builtin_va_arg(args,AFun));
        break;
# 207 "/scratch/mcrl2_regressiontest/trunk/libraries/core/source/print_c.cpp"
      default:
        fputc(*p, stream);
        break;
    }
  }
  return result;
}

  }
}